//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Imagebuilder service.
///
/// EC2 Image Builder is a fully managed Amazon Web Services service that makes it easier to automate the
/// 			creation, management, and deployment of customized, secure, and up-to-date
/// 			"golden" server images that are pre-installed and pre-configured with software
/// 			and settings to meet specific IT standards.
public struct Imagebuilder: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Imagebuilder client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "Imagebuilder",
            serviceIdentifier: "imagebuilder",
            serviceProtocol: .restjson,
            apiVersion: "2019-12-02",
            endpoint: endpoint,
            errorType: ImagebuilderErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// CancelImageCreation cancels the creation of Image. This operation can only be used on
    /// 			images in a non-terminal state.
    @Sendable
    @inlinable
    public func cancelImageCreation(_ input: CancelImageCreationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelImageCreationResponse {
        try await self.client.execute(
            operation: "CancelImageCreation", 
            path: "/CancelImageCreation", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// CancelImageCreation cancels the creation of Image. This operation can only be used on
    /// 			images in a non-terminal state.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - imageBuildVersionArn: The Amazon Resource Name (ARN) of the image that you want to cancel creation
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelImageCreation(
        clientToken: String = CancelImageCreationRequest.idempotencyToken(),
        imageBuildVersionArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelImageCreationResponse {
        let input = CancelImageCreationRequest(
            clientToken: clientToken, 
            imageBuildVersionArn: imageBuildVersionArn
        )
        return try await self.cancelImageCreation(input, logger: logger)
    }

    /// Cancel a specific image lifecycle policy runtime instance.
    @Sendable
    @inlinable
    public func cancelLifecycleExecution(_ input: CancelLifecycleExecutionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelLifecycleExecutionResponse {
        try await self.client.execute(
            operation: "CancelLifecycleExecution", 
            path: "/CancelLifecycleExecution", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancel a specific image lifecycle policy runtime instance.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - lifecycleExecutionId: Identifies the specific runtime instance of the image lifecycle to cancel.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelLifecycleExecution(
        clientToken: String = CancelLifecycleExecutionRequest.idempotencyToken(),
        lifecycleExecutionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelLifecycleExecutionResponse {
        let input = CancelLifecycleExecutionRequest(
            clientToken: clientToken, 
            lifecycleExecutionId: lifecycleExecutionId
        )
        return try await self.cancelLifecycleExecution(input, logger: logger)
    }

    /// Creates a new component that can be used to build, validate, test, and assess your
    /// 			image. The component is based on a YAML document that you specify using exactly one of
    /// 			the following methods:   Inline, using the data property in the request body.   A URL that points to a YAML document file stored in Amazon S3, using the
    /// 						uri property in the request body.
    @Sendable
    @inlinable
    public func createComponent(_ input: CreateComponentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateComponentResponse {
        try await self.client.execute(
            operation: "CreateComponent", 
            path: "/CreateComponent", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new component that can be used to build, validate, test, and assess your
    /// 			image. The component is based on a YAML document that you specify using exactly one of
    /// 			the following methods:   Inline, using the data property in the request body.   A URL that points to a YAML document file stored in Amazon S3, using the
    /// 						uri property in the request body.
    ///
    /// Parameters:
    ///   - changeDescription: The change description of the component. Describes what change has been made in this
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - data: Component data contains inline YAML document content for the component.
    ///   - description: Describes the contents of the component.
    ///   - kmsKeyId: The Amazon Resource Name (ARN) that uniquely identifies the KMS key used to encrypt this component. This can be either the Key ARN or the Alias ARN. For more information, see Key identifiers (KeyId)
    ///   - name: The name of the component.
    ///   - platform: The operating system platform of the component.
    ///   - semanticVersion: The semantic version of the component. This version follows the semantic version
    ///   - supportedOsVersions: The operating system (OS) version supported by the component. If the OS information is
    ///   - tags: The tags that apply to the component.
    ///   - uri: The uri of a YAML component document file. This must be an S3 URL
    ///   - logger: Logger use during operation
    @inlinable
    public func createComponent(
        changeDescription: String? = nil,
        clientToken: String = CreateComponentRequest.idempotencyToken(),
        data: String? = nil,
        description: String? = nil,
        kmsKeyId: String? = nil,
        name: String,
        platform: Platform,
        semanticVersion: String,
        supportedOsVersions: [String]? = nil,
        tags: [String: String]? = nil,
        uri: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateComponentResponse {
        let input = CreateComponentRequest(
            changeDescription: changeDescription, 
            clientToken: clientToken, 
            data: data, 
            description: description, 
            kmsKeyId: kmsKeyId, 
            name: name, 
            platform: platform, 
            semanticVersion: semanticVersion, 
            supportedOsVersions: supportedOsVersions, 
            tags: tags, 
            uri: uri
        )
        return try await self.createComponent(input, logger: logger)
    }

    /// Creates a new container recipe. Container recipes define how images are configured,
    /// 			tested, and assessed.
    @Sendable
    @inlinable
    public func createContainerRecipe(_ input: CreateContainerRecipeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateContainerRecipeResponse {
        try await self.client.execute(
            operation: "CreateContainerRecipe", 
            path: "/CreateContainerRecipe", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new container recipe. Container recipes define how images are configured,
    /// 			tested, and assessed.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - components: Components for build and test that are included in the container recipe.
    ///   - containerType: The type of container to create.
    ///   - description: The description of the container recipe.
    ///   - dockerfileTemplateData: The Dockerfile template used to build your image as an inline data blob.
    ///   - dockerfileTemplateUri: The Amazon S3 URI for the Dockerfile that will be used to build your container
    ///   - imageOsVersionOverride: Specifies the operating system version for the base image.
    ///   - instanceConfiguration: A group of options that can be used to configure an instance for building and testing
    ///   - kmsKeyId: The Amazon Resource Name (ARN) that uniquely identifies which KMS key is used to encrypt the Dockerfile
    ///   - name: The name of the container recipe.
    ///   - parentImage: The base image for the container recipe.
    ///   - platformOverride: Specifies the operating system platform when you use a custom base image.
    ///   - semanticVersion: The semantic version of the container recipe. This version follows the semantic
    ///   - tags: Tags that are attached to the container recipe.
    ///   - targetRepository: The destination repository for the container image.
    ///   - workingDirectory: The working directory for use during build and test workflows.
    ///   - logger: Logger use during operation
    @inlinable
    public func createContainerRecipe(
        clientToken: String = CreateContainerRecipeRequest.idempotencyToken(),
        components: [ComponentConfiguration],
        containerType: ContainerType,
        description: String? = nil,
        dockerfileTemplateData: String? = nil,
        dockerfileTemplateUri: String? = nil,
        imageOsVersionOverride: String? = nil,
        instanceConfiguration: InstanceConfiguration? = nil,
        kmsKeyId: String? = nil,
        name: String,
        parentImage: String,
        platformOverride: Platform? = nil,
        semanticVersion: String,
        tags: [String: String]? = nil,
        targetRepository: TargetContainerRepository,
        workingDirectory: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateContainerRecipeResponse {
        let input = CreateContainerRecipeRequest(
            clientToken: clientToken, 
            components: components, 
            containerType: containerType, 
            description: description, 
            dockerfileTemplateData: dockerfileTemplateData, 
            dockerfileTemplateUri: dockerfileTemplateUri, 
            imageOsVersionOverride: imageOsVersionOverride, 
            instanceConfiguration: instanceConfiguration, 
            kmsKeyId: kmsKeyId, 
            name: name, 
            parentImage: parentImage, 
            platformOverride: platformOverride, 
            semanticVersion: semanticVersion, 
            tags: tags, 
            targetRepository: targetRepository, 
            workingDirectory: workingDirectory
        )
        return try await self.createContainerRecipe(input, logger: logger)
    }

    /// Creates a new distribution configuration. Distribution configurations define and
    /// 			configure the outputs of your pipeline.
    @Sendable
    @inlinable
    public func createDistributionConfiguration(_ input: CreateDistributionConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDistributionConfigurationResponse {
        try await self.client.execute(
            operation: "CreateDistributionConfiguration", 
            path: "/CreateDistributionConfiguration", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new distribution configuration. Distribution configurations define and
    /// 			configure the outputs of your pipeline.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - description: The description of the distribution configuration.
    ///   - distributions: The distributions of the distribution configuration.
    ///   - name: The name of the distribution configuration.
    ///   - tags: The tags of the distribution configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDistributionConfiguration(
        clientToken: String = CreateDistributionConfigurationRequest.idempotencyToken(),
        description: String? = nil,
        distributions: [Distribution],
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDistributionConfigurationResponse {
        let input = CreateDistributionConfigurationRequest(
            clientToken: clientToken, 
            description: description, 
            distributions: distributions, 
            name: name, 
            tags: tags
        )
        return try await self.createDistributionConfiguration(input, logger: logger)
    }

    /// Creates a new image. This request will create a new image along with all of the
    /// 			configured output resources defined in the distribution configuration. You must specify
    /// 			exactly one recipe for your image, using either a ContainerRecipeArn or an
    /// 			ImageRecipeArn.
    @Sendable
    @inlinable
    public func createImage(_ input: CreateImageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateImageResponse {
        try await self.client.execute(
            operation: "CreateImage", 
            path: "/CreateImage", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new image. This request will create a new image along with all of the
    /// 			configured output resources defined in the distribution configuration. You must specify
    /// 			exactly one recipe for your image, using either a ContainerRecipeArn or an
    /// 			ImageRecipeArn.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - containerRecipeArn: The Amazon Resource Name (ARN) of the container recipe that defines how images are
    ///   - distributionConfigurationArn: The Amazon Resource Name (ARN) of the distribution configuration that defines and
    ///   - enhancedImageMetadataEnabled: Collects additional information about the image being created, including the operating
    ///   - executionRole: The name or Amazon Resource Name (ARN) for the IAM role you create that grants
    ///   - imageRecipeArn: The Amazon Resource Name (ARN) of the image recipe that defines how images are
    ///   - imageScanningConfiguration: Contains settings for vulnerability scans.
    ///   - imageTestsConfiguration: The image tests configuration of the image.
    ///   - infrastructureConfigurationArn: The Amazon Resource Name (ARN) of the infrastructure configuration that defines the
    ///   - loggingConfiguration: Define logging configuration for the image build process.
    ///   - tags: The tags of the image.
    ///   - workflows: Contains an array of workflow configuration objects.
    ///   - logger: Logger use during operation
    @inlinable
    public func createImage(
        clientToken: String = CreateImageRequest.idempotencyToken(),
        containerRecipeArn: String? = nil,
        distributionConfigurationArn: String? = nil,
        enhancedImageMetadataEnabled: Bool? = nil,
        executionRole: String? = nil,
        imageRecipeArn: String? = nil,
        imageScanningConfiguration: ImageScanningConfiguration? = nil,
        imageTestsConfiguration: ImageTestsConfiguration? = nil,
        infrastructureConfigurationArn: String,
        loggingConfiguration: ImageLoggingConfiguration? = nil,
        tags: [String: String]? = nil,
        workflows: [WorkflowConfiguration]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateImageResponse {
        let input = CreateImageRequest(
            clientToken: clientToken, 
            containerRecipeArn: containerRecipeArn, 
            distributionConfigurationArn: distributionConfigurationArn, 
            enhancedImageMetadataEnabled: enhancedImageMetadataEnabled, 
            executionRole: executionRole, 
            imageRecipeArn: imageRecipeArn, 
            imageScanningConfiguration: imageScanningConfiguration, 
            imageTestsConfiguration: imageTestsConfiguration, 
            infrastructureConfigurationArn: infrastructureConfigurationArn, 
            loggingConfiguration: loggingConfiguration, 
            tags: tags, 
            workflows: workflows
        )
        return try await self.createImage(input, logger: logger)
    }

    /// Creates a new image pipeline. Image pipelines enable you to automate the creation and
    /// 			distribution of images.
    @Sendable
    @inlinable
    public func createImagePipeline(_ input: CreateImagePipelineRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateImagePipelineResponse {
        try await self.client.execute(
            operation: "CreateImagePipeline", 
            path: "/CreateImagePipeline", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new image pipeline. Image pipelines enable you to automate the creation and
    /// 			distribution of images.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - containerRecipeArn: The Amazon Resource Name (ARN) of the container recipe that is used to configure
    ///   - description: The description of the image pipeline.
    ///   - distributionConfigurationArn: The Amazon Resource Name (ARN) of the distribution configuration that will be used to
    ///   - enhancedImageMetadataEnabled: Collects additional information about the image being created, including the operating
    ///   - executionRole: The name or Amazon Resource Name (ARN) for the IAM role you create that grants
    ///   - imageRecipeArn: The Amazon Resource Name (ARN) of the image recipe that will be used to configure
    ///   - imageScanningConfiguration: Contains settings for vulnerability scans.
    ///   - imageTestsConfiguration: The image test configuration of the image pipeline.
    ///   - infrastructureConfigurationArn: The Amazon Resource Name (ARN) of the infrastructure configuration that will be used
    ///   - loggingConfiguration: Define logging configuration for the image build process.
    ///   - name: The name of the image pipeline.
    ///   - schedule: The schedule of the image pipeline.
    ///   - status: The status of the image pipeline.
    ///   - tags: The tags of the image pipeline.
    ///   - workflows: Contains an array of workflow configuration objects.
    ///   - logger: Logger use during operation
    @inlinable
    public func createImagePipeline(
        clientToken: String = CreateImagePipelineRequest.idempotencyToken(),
        containerRecipeArn: String? = nil,
        description: String? = nil,
        distributionConfigurationArn: String? = nil,
        enhancedImageMetadataEnabled: Bool? = nil,
        executionRole: String? = nil,
        imageRecipeArn: String? = nil,
        imageScanningConfiguration: ImageScanningConfiguration? = nil,
        imageTestsConfiguration: ImageTestsConfiguration? = nil,
        infrastructureConfigurationArn: String,
        loggingConfiguration: PipelineLoggingConfiguration? = nil,
        name: String,
        schedule: Schedule? = nil,
        status: PipelineStatus? = nil,
        tags: [String: String]? = nil,
        workflows: [WorkflowConfiguration]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateImagePipelineResponse {
        let input = CreateImagePipelineRequest(
            clientToken: clientToken, 
            containerRecipeArn: containerRecipeArn, 
            description: description, 
            distributionConfigurationArn: distributionConfigurationArn, 
            enhancedImageMetadataEnabled: enhancedImageMetadataEnabled, 
            executionRole: executionRole, 
            imageRecipeArn: imageRecipeArn, 
            imageScanningConfiguration: imageScanningConfiguration, 
            imageTestsConfiguration: imageTestsConfiguration, 
            infrastructureConfigurationArn: infrastructureConfigurationArn, 
            loggingConfiguration: loggingConfiguration, 
            name: name, 
            schedule: schedule, 
            status: status, 
            tags: tags, 
            workflows: workflows
        )
        return try await self.createImagePipeline(input, logger: logger)
    }

    /// Creates a new image recipe. Image recipes define how images are configured, tested,
    /// 			and assessed.
    @Sendable
    @inlinable
    public func createImageRecipe(_ input: CreateImageRecipeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateImageRecipeResponse {
        try await self.client.execute(
            operation: "CreateImageRecipe", 
            path: "/CreateImageRecipe", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new image recipe. Image recipes define how images are configured, tested,
    /// 			and assessed.
    ///
    /// Parameters:
    ///   - additionalInstanceConfiguration: Specify additional settings and launch scripts for your build instances.
    ///   - amiTags: Tags that are applied to the AMI that Image Builder creates during the Build phase
    ///   - blockDeviceMappings: The block device mappings of the image recipe.
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - components: The components included in the image recipe.
    ///   - description: The description of the image recipe.
    ///   - name: The name of the image recipe.
    ///   - parentImage: The base image for customizations specified in the image recipe. You can specify the
    ///   - semanticVersion: The semantic version of the image recipe. This version follows the semantic version
    ///   - tags: The tags of the image recipe.
    ///   - workingDirectory: The working directory used during build and test workflows.
    ///   - logger: Logger use during operation
    @inlinable
    public func createImageRecipe(
        additionalInstanceConfiguration: AdditionalInstanceConfiguration? = nil,
        amiTags: [String: String]? = nil,
        blockDeviceMappings: [InstanceBlockDeviceMapping]? = nil,
        clientToken: String = CreateImageRecipeRequest.idempotencyToken(),
        components: [ComponentConfiguration],
        description: String? = nil,
        name: String,
        parentImage: String,
        semanticVersion: String,
        tags: [String: String]? = nil,
        workingDirectory: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateImageRecipeResponse {
        let input = CreateImageRecipeRequest(
            additionalInstanceConfiguration: additionalInstanceConfiguration, 
            amiTags: amiTags, 
            blockDeviceMappings: blockDeviceMappings, 
            clientToken: clientToken, 
            components: components, 
            description: description, 
            name: name, 
            parentImage: parentImage, 
            semanticVersion: semanticVersion, 
            tags: tags, 
            workingDirectory: workingDirectory
        )
        return try await self.createImageRecipe(input, logger: logger)
    }

    /// Creates a new infrastructure configuration. An infrastructure configuration defines
    /// 			the environment in which your image will be built and tested.
    @Sendable
    @inlinable
    public func createInfrastructureConfiguration(_ input: CreateInfrastructureConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateInfrastructureConfigurationResponse {
        try await self.client.execute(
            operation: "CreateInfrastructureConfiguration", 
            path: "/CreateInfrastructureConfiguration", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new infrastructure configuration. An infrastructure configuration defines
    /// 			the environment in which your image will be built and tested.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - description: The description of the infrastructure configuration.
    ///   - instanceMetadataOptions: The instance metadata options that you can set for the HTTP requests that pipeline
    ///   - instanceProfileName: The instance profile to associate with the instance used to customize your Amazon EC2
    ///   - instanceTypes: The instance types of the infrastructure configuration. You can specify one or more
    ///   - keyPair: The key pair of the infrastructure configuration. You can use this to log on to and
    ///   - logging: The logging configuration of the infrastructure configuration.
    ///   - name: The name of the infrastructure configuration.
    ///   - placement: The instance placement settings that define where the instances that are launched
    ///   - resourceTags: The metadata tags to assign to the Amazon EC2 instance that Image Builder launches during the build process.
    ///   - securityGroupIds: The security group IDs to associate with the instance used to customize your Amazon EC2
    ///   - snsTopicArn: The Amazon Resource Name (ARN) for the SNS topic to which we send image build event
    ///   - subnetId: The subnet ID in which to place the instance used to customize your Amazon EC2 AMI.
    ///   - tags: The metadata tags to assign to the infrastructure configuration resource that Image Builder
    ///   - terminateInstanceOnFailure: The terminate instance on failure setting of the infrastructure configuration. Set to
    ///   - logger: Logger use during operation
    @inlinable
    public func createInfrastructureConfiguration(
        clientToken: String = CreateInfrastructureConfigurationRequest.idempotencyToken(),
        description: String? = nil,
        instanceMetadataOptions: InstanceMetadataOptions? = nil,
        instanceProfileName: String,
        instanceTypes: [String]? = nil,
        keyPair: String? = nil,
        logging: Logging? = nil,
        name: String,
        placement: Placement? = nil,
        resourceTags: [String: String]? = nil,
        securityGroupIds: [String]? = nil,
        snsTopicArn: String? = nil,
        subnetId: String? = nil,
        tags: [String: String]? = nil,
        terminateInstanceOnFailure: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateInfrastructureConfigurationResponse {
        let input = CreateInfrastructureConfigurationRequest(
            clientToken: clientToken, 
            description: description, 
            instanceMetadataOptions: instanceMetadataOptions, 
            instanceProfileName: instanceProfileName, 
            instanceTypes: instanceTypes, 
            keyPair: keyPair, 
            logging: logging, 
            name: name, 
            placement: placement, 
            resourceTags: resourceTags, 
            securityGroupIds: securityGroupIds, 
            snsTopicArn: snsTopicArn, 
            subnetId: subnetId, 
            tags: tags, 
            terminateInstanceOnFailure: terminateInstanceOnFailure
        )
        return try await self.createInfrastructureConfiguration(input, logger: logger)
    }

    /// Create a lifecycle policy resource.
    @Sendable
    @inlinable
    public func createLifecyclePolicy(_ input: CreateLifecyclePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateLifecyclePolicyResponse {
        try await self.client.execute(
            operation: "CreateLifecyclePolicy", 
            path: "/CreateLifecyclePolicy", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Create a lifecycle policy resource.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - description: Optional description for the lifecycle policy.
    ///   - executionRole: The name or Amazon Resource Name (ARN) for the IAM role you create that grants
    ///   - name: The name of the  lifecycle policy to create.
    ///   - policyDetails: Configuration details for the lifecycle policy rules.
    ///   - resourceSelection: Selection criteria for the resources that the lifecycle policy applies to.
    ///   - resourceType: The type of Image Builder resource that the lifecycle policy applies to.
    ///   - status: Indicates whether the lifecycle policy resource is enabled.
    ///   - tags: Tags to apply to the lifecycle policy resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createLifecyclePolicy(
        clientToken: String = CreateLifecyclePolicyRequest.idempotencyToken(),
        description: String? = nil,
        executionRole: String,
        name: String,
        policyDetails: [LifecyclePolicyDetail],
        resourceSelection: LifecyclePolicyResourceSelection,
        resourceType: LifecyclePolicyResourceType,
        status: LifecyclePolicyStatus? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateLifecyclePolicyResponse {
        let input = CreateLifecyclePolicyRequest(
            clientToken: clientToken, 
            description: description, 
            executionRole: executionRole, 
            name: name, 
            policyDetails: policyDetails, 
            resourceSelection: resourceSelection, 
            resourceType: resourceType, 
            status: status, 
            tags: tags
        )
        return try await self.createLifecyclePolicy(input, logger: logger)
    }

    /// Create a new workflow or a new version of an existing workflow.
    @Sendable
    @inlinable
    public func createWorkflow(_ input: CreateWorkflowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateWorkflowResponse {
        try await self.client.execute(
            operation: "CreateWorkflow", 
            path: "/CreateWorkflow", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Create a new workflow or a new version of an existing workflow.
    ///
    /// Parameters:
    ///   - changeDescription: Describes what change has been made in this version of the workflow, or
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - data: Contains the UTF-8 encoded YAML document content for the workflow.
    ///   - description: Describes the workflow.
    ///   - kmsKeyId: The Amazon Resource Name (ARN) that uniquely identifies the KMS key used to encrypt this workflow resource.
    ///   - name: The name of the workflow to create.
    ///   - semanticVersion: The semantic version of this workflow resource. The semantic version syntax
    ///   - tags: Tags that apply to the workflow resource.
    ///   - type: The phase in the image build process for which the workflow resource
    ///   - uri: The uri of a YAML component document file. This must be an S3 URL
    ///   - logger: Logger use during operation
    @inlinable
    public func createWorkflow(
        changeDescription: String? = nil,
        clientToken: String = CreateWorkflowRequest.idempotencyToken(),
        data: String? = nil,
        description: String? = nil,
        kmsKeyId: String? = nil,
        name: String,
        semanticVersion: String,
        tags: [String: String]? = nil,
        type: WorkflowType,
        uri: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateWorkflowResponse {
        let input = CreateWorkflowRequest(
            changeDescription: changeDescription, 
            clientToken: clientToken, 
            data: data, 
            description: description, 
            kmsKeyId: kmsKeyId, 
            name: name, 
            semanticVersion: semanticVersion, 
            tags: tags, 
            type: type, 
            uri: uri
        )
        return try await self.createWorkflow(input, logger: logger)
    }

    /// Deletes a component build version.
    @Sendable
    @inlinable
    public func deleteComponent(_ input: DeleteComponentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteComponentResponse {
        try await self.client.execute(
            operation: "DeleteComponent", 
            path: "/DeleteComponent", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a component build version.
    ///
    /// Parameters:
    ///   - componentBuildVersionArn: The Amazon Resource Name (ARN) of the component build version to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteComponent(
        componentBuildVersionArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteComponentResponse {
        let input = DeleteComponentRequest(
            componentBuildVersionArn: componentBuildVersionArn
        )
        return try await self.deleteComponent(input, logger: logger)
    }

    /// Deletes a container recipe.
    @Sendable
    @inlinable
    public func deleteContainerRecipe(_ input: DeleteContainerRecipeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteContainerRecipeResponse {
        try await self.client.execute(
            operation: "DeleteContainerRecipe", 
            path: "/DeleteContainerRecipe", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a container recipe.
    ///
    /// Parameters:
    ///   - containerRecipeArn: The Amazon Resource Name (ARN) of the container recipe to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteContainerRecipe(
        containerRecipeArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteContainerRecipeResponse {
        let input = DeleteContainerRecipeRequest(
            containerRecipeArn: containerRecipeArn
        )
        return try await self.deleteContainerRecipe(input, logger: logger)
    }

    /// Deletes a distribution configuration.
    @Sendable
    @inlinable
    public func deleteDistributionConfiguration(_ input: DeleteDistributionConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteDistributionConfigurationResponse {
        try await self.client.execute(
            operation: "DeleteDistributionConfiguration", 
            path: "/DeleteDistributionConfiguration", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a distribution configuration.
    ///
    /// Parameters:
    ///   - distributionConfigurationArn: The Amazon Resource Name (ARN) of the distribution configuration to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDistributionConfiguration(
        distributionConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteDistributionConfigurationResponse {
        let input = DeleteDistributionConfigurationRequest(
            distributionConfigurationArn: distributionConfigurationArn
        )
        return try await self.deleteDistributionConfiguration(input, logger: logger)
    }

    /// Deletes an Image Builder image resource. This does not delete any EC2 AMIs or ECR container
    /// 			images that are created during the image build process. You must clean those up
    /// 			separately, using the appropriate Amazon EC2 or Amazon ECR console actions, or API or CLI
    /// 			commands.   To deregister an EC2 Linux AMI, see Deregister your
    /// 						Linux AMI in the  Amazon EC2 User Guide .   To deregister an EC2 Windows AMI, see Deregister your
    /// 						Windows AMI in the  Amazon EC2 Windows Guide .   To delete a container image from Amazon ECR, see Deleting
    /// 						an image in the Amazon ECR User Guide.
    @Sendable
    @inlinable
    public func deleteImage(_ input: DeleteImageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteImageResponse {
        try await self.client.execute(
            operation: "DeleteImage", 
            path: "/DeleteImage", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Image Builder image resource. This does not delete any EC2 AMIs or ECR container
    /// 			images that are created during the image build process. You must clean those up
    /// 			separately, using the appropriate Amazon EC2 or Amazon ECR console actions, or API or CLI
    /// 			commands.   To deregister an EC2 Linux AMI, see Deregister your
    /// 						Linux AMI in the  Amazon EC2 User Guide .   To deregister an EC2 Windows AMI, see Deregister your
    /// 						Windows AMI in the  Amazon EC2 Windows Guide .   To delete a container image from Amazon ECR, see Deleting
    /// 						an image in the Amazon ECR User Guide.
    ///
    /// Parameters:
    ///   - imageBuildVersionArn: The Amazon Resource Name (ARN) of the Image Builder image resource to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteImage(
        imageBuildVersionArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteImageResponse {
        let input = DeleteImageRequest(
            imageBuildVersionArn: imageBuildVersionArn
        )
        return try await self.deleteImage(input, logger: logger)
    }

    /// Deletes an image pipeline.
    @Sendable
    @inlinable
    public func deleteImagePipeline(_ input: DeleteImagePipelineRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteImagePipelineResponse {
        try await self.client.execute(
            operation: "DeleteImagePipeline", 
            path: "/DeleteImagePipeline", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an image pipeline.
    ///
    /// Parameters:
    ///   - imagePipelineArn: The Amazon Resource Name (ARN) of the image pipeline to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteImagePipeline(
        imagePipelineArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteImagePipelineResponse {
        let input = DeleteImagePipelineRequest(
            imagePipelineArn: imagePipelineArn
        )
        return try await self.deleteImagePipeline(input, logger: logger)
    }

    /// Deletes an image recipe.
    @Sendable
    @inlinable
    public func deleteImageRecipe(_ input: DeleteImageRecipeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteImageRecipeResponse {
        try await self.client.execute(
            operation: "DeleteImageRecipe", 
            path: "/DeleteImageRecipe", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an image recipe.
    ///
    /// Parameters:
    ///   - imageRecipeArn: The Amazon Resource Name (ARN) of the image recipe to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteImageRecipe(
        imageRecipeArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteImageRecipeResponse {
        let input = DeleteImageRecipeRequest(
            imageRecipeArn: imageRecipeArn
        )
        return try await self.deleteImageRecipe(input, logger: logger)
    }

    /// Deletes an infrastructure configuration.
    @Sendable
    @inlinable
    public func deleteInfrastructureConfiguration(_ input: DeleteInfrastructureConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteInfrastructureConfigurationResponse {
        try await self.client.execute(
            operation: "DeleteInfrastructureConfiguration", 
            path: "/DeleteInfrastructureConfiguration", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an infrastructure configuration.
    ///
    /// Parameters:
    ///   - infrastructureConfigurationArn: The Amazon Resource Name (ARN) of the infrastructure configuration to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteInfrastructureConfiguration(
        infrastructureConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteInfrastructureConfigurationResponse {
        let input = DeleteInfrastructureConfigurationRequest(
            infrastructureConfigurationArn: infrastructureConfigurationArn
        )
        return try await self.deleteInfrastructureConfiguration(input, logger: logger)
    }

    /// Delete the specified lifecycle policy resource.
    @Sendable
    @inlinable
    public func deleteLifecyclePolicy(_ input: DeleteLifecyclePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteLifecyclePolicyResponse {
        try await self.client.execute(
            operation: "DeleteLifecyclePolicy", 
            path: "/DeleteLifecyclePolicy", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete the specified lifecycle policy resource.
    ///
    /// Parameters:
    ///   - lifecyclePolicyArn: The Amazon Resource Name (ARN) of the lifecycle policy resource to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteLifecyclePolicy(
        lifecyclePolicyArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteLifecyclePolicyResponse {
        let input = DeleteLifecyclePolicyRequest(
            lifecyclePolicyArn: lifecyclePolicyArn
        )
        return try await self.deleteLifecyclePolicy(input, logger: logger)
    }

    /// Deletes a specific workflow resource.
    @Sendable
    @inlinable
    public func deleteWorkflow(_ input: DeleteWorkflowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteWorkflowResponse {
        try await self.client.execute(
            operation: "DeleteWorkflow", 
            path: "/DeleteWorkflow", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a specific workflow resource.
    ///
    /// Parameters:
    ///   - workflowBuildVersionArn: The Amazon Resource Name (ARN) of the workflow resource to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteWorkflow(
        workflowBuildVersionArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteWorkflowResponse {
        let input = DeleteWorkflowRequest(
            workflowBuildVersionArn: workflowBuildVersionArn
        )
        return try await self.deleteWorkflow(input, logger: logger)
    }

    /// Gets a component object.
    @Sendable
    @inlinable
    public func getComponent(_ input: GetComponentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetComponentResponse {
        try await self.client.execute(
            operation: "GetComponent", 
            path: "/GetComponent", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a component object.
    ///
    /// Parameters:
    ///   - componentBuildVersionArn: The Amazon Resource Name (ARN) of the component that you want to get. Regex requires
    ///   - logger: Logger use during operation
    @inlinable
    public func getComponent(
        componentBuildVersionArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetComponentResponse {
        let input = GetComponentRequest(
            componentBuildVersionArn: componentBuildVersionArn
        )
        return try await self.getComponent(input, logger: logger)
    }

    /// Gets a component policy.
    @Sendable
    @inlinable
    public func getComponentPolicy(_ input: GetComponentPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetComponentPolicyResponse {
        try await self.client.execute(
            operation: "GetComponentPolicy", 
            path: "/GetComponentPolicy", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a component policy.
    ///
    /// Parameters:
    ///   - componentArn: The Amazon Resource Name (ARN) of the component whose policy you want to
    ///   - logger: Logger use during operation
    @inlinable
    public func getComponentPolicy(
        componentArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetComponentPolicyResponse {
        let input = GetComponentPolicyRequest(
            componentArn: componentArn
        )
        return try await self.getComponentPolicy(input, logger: logger)
    }

    /// Retrieves a container recipe.
    @Sendable
    @inlinable
    public func getContainerRecipe(_ input: GetContainerRecipeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetContainerRecipeResponse {
        try await self.client.execute(
            operation: "GetContainerRecipe", 
            path: "/GetContainerRecipe", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a container recipe.
    ///
    /// Parameters:
    ///   - containerRecipeArn: The Amazon Resource Name (ARN) of the container recipe to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getContainerRecipe(
        containerRecipeArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetContainerRecipeResponse {
        let input = GetContainerRecipeRequest(
            containerRecipeArn: containerRecipeArn
        )
        return try await self.getContainerRecipe(input, logger: logger)
    }

    /// Retrieves the policy for a container recipe.
    @Sendable
    @inlinable
    public func getContainerRecipePolicy(_ input: GetContainerRecipePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetContainerRecipePolicyResponse {
        try await self.client.execute(
            operation: "GetContainerRecipePolicy", 
            path: "/GetContainerRecipePolicy", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the policy for a container recipe.
    ///
    /// Parameters:
    ///   - containerRecipeArn: The Amazon Resource Name (ARN) of the container recipe for the policy being
    ///   - logger: Logger use during operation
    @inlinable
    public func getContainerRecipePolicy(
        containerRecipeArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetContainerRecipePolicyResponse {
        let input = GetContainerRecipePolicyRequest(
            containerRecipeArn: containerRecipeArn
        )
        return try await self.getContainerRecipePolicy(input, logger: logger)
    }

    /// Gets a distribution configuration.
    @Sendable
    @inlinable
    public func getDistributionConfiguration(_ input: GetDistributionConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDistributionConfigurationResponse {
        try await self.client.execute(
            operation: "GetDistributionConfiguration", 
            path: "/GetDistributionConfiguration", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a distribution configuration.
    ///
    /// Parameters:
    ///   - distributionConfigurationArn: The Amazon Resource Name (ARN) of the distribution configuration that you want to
    ///   - logger: Logger use during operation
    @inlinable
    public func getDistributionConfiguration(
        distributionConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDistributionConfigurationResponse {
        let input = GetDistributionConfigurationRequest(
            distributionConfigurationArn: distributionConfigurationArn
        )
        return try await self.getDistributionConfiguration(input, logger: logger)
    }

    /// Gets an image.
    @Sendable
    @inlinable
    public func getImage(_ input: GetImageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetImageResponse {
        try await self.client.execute(
            operation: "GetImage", 
            path: "/GetImage", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets an image.
    ///
    /// Parameters:
    ///   - imageBuildVersionArn: The Amazon Resource Name (ARN) of the image that you want to get.
    ///   - logger: Logger use during operation
    @inlinable
    public func getImage(
        imageBuildVersionArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetImageResponse {
        let input = GetImageRequest(
            imageBuildVersionArn: imageBuildVersionArn
        )
        return try await self.getImage(input, logger: logger)
    }

    /// Gets an image pipeline.
    @Sendable
    @inlinable
    public func getImagePipeline(_ input: GetImagePipelineRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetImagePipelineResponse {
        try await self.client.execute(
            operation: "GetImagePipeline", 
            path: "/GetImagePipeline", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets an image pipeline.
    ///
    /// Parameters:
    ///   - imagePipelineArn: The Amazon Resource Name (ARN) of the image pipeline that you want to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getImagePipeline(
        imagePipelineArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetImagePipelineResponse {
        let input = GetImagePipelineRequest(
            imagePipelineArn: imagePipelineArn
        )
        return try await self.getImagePipeline(input, logger: logger)
    }

    /// Gets an image policy.
    @Sendable
    @inlinable
    public func getImagePolicy(_ input: GetImagePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetImagePolicyResponse {
        try await self.client.execute(
            operation: "GetImagePolicy", 
            path: "/GetImagePolicy", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets an image policy.
    ///
    /// Parameters:
    ///   - imageArn: The Amazon Resource Name (ARN) of the image whose policy you want to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getImagePolicy(
        imageArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetImagePolicyResponse {
        let input = GetImagePolicyRequest(
            imageArn: imageArn
        )
        return try await self.getImagePolicy(input, logger: logger)
    }

    /// Gets an image recipe.
    @Sendable
    @inlinable
    public func getImageRecipe(_ input: GetImageRecipeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetImageRecipeResponse {
        try await self.client.execute(
            operation: "GetImageRecipe", 
            path: "/GetImageRecipe", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets an image recipe.
    ///
    /// Parameters:
    ///   - imageRecipeArn: The Amazon Resource Name (ARN) of the image recipe that you want to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getImageRecipe(
        imageRecipeArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetImageRecipeResponse {
        let input = GetImageRecipeRequest(
            imageRecipeArn: imageRecipeArn
        )
        return try await self.getImageRecipe(input, logger: logger)
    }

    /// Gets an image recipe policy.
    @Sendable
    @inlinable
    public func getImageRecipePolicy(_ input: GetImageRecipePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetImageRecipePolicyResponse {
        try await self.client.execute(
            operation: "GetImageRecipePolicy", 
            path: "/GetImageRecipePolicy", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets an image recipe policy.
    ///
    /// Parameters:
    ///   - imageRecipeArn: The Amazon Resource Name (ARN) of the image recipe whose policy you want to
    ///   - logger: Logger use during operation
    @inlinable
    public func getImageRecipePolicy(
        imageRecipeArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetImageRecipePolicyResponse {
        let input = GetImageRecipePolicyRequest(
            imageRecipeArn: imageRecipeArn
        )
        return try await self.getImageRecipePolicy(input, logger: logger)
    }

    /// Gets an infrastructure configuration.
    @Sendable
    @inlinable
    public func getInfrastructureConfiguration(_ input: GetInfrastructureConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetInfrastructureConfigurationResponse {
        try await self.client.execute(
            operation: "GetInfrastructureConfiguration", 
            path: "/GetInfrastructureConfiguration", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets an infrastructure configuration.
    ///
    /// Parameters:
    ///   - infrastructureConfigurationArn: The Amazon Resource Name (ARN) of the infrastructure configuration that you want to
    ///   - logger: Logger use during operation
    @inlinable
    public func getInfrastructureConfiguration(
        infrastructureConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetInfrastructureConfigurationResponse {
        let input = GetInfrastructureConfigurationRequest(
            infrastructureConfigurationArn: infrastructureConfigurationArn
        )
        return try await self.getInfrastructureConfiguration(input, logger: logger)
    }

    /// Get the runtime information that was logged for a specific runtime instance of the lifecycle policy.
    @Sendable
    @inlinable
    public func getLifecycleExecution(_ input: GetLifecycleExecutionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetLifecycleExecutionResponse {
        try await self.client.execute(
            operation: "GetLifecycleExecution", 
            path: "/GetLifecycleExecution", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the runtime information that was logged for a specific runtime instance of the lifecycle policy.
    ///
    /// Parameters:
    ///   - lifecycleExecutionId: Use the unique identifier for a runtime instance of the lifecycle policy to get runtime details.
    ///   - logger: Logger use during operation
    @inlinable
    public func getLifecycleExecution(
        lifecycleExecutionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetLifecycleExecutionResponse {
        let input = GetLifecycleExecutionRequest(
            lifecycleExecutionId: lifecycleExecutionId
        )
        return try await self.getLifecycleExecution(input, logger: logger)
    }

    /// Get details for the specified image lifecycle policy.
    @Sendable
    @inlinable
    public func getLifecyclePolicy(_ input: GetLifecyclePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetLifecyclePolicyResponse {
        try await self.client.execute(
            operation: "GetLifecyclePolicy", 
            path: "/GetLifecyclePolicy", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get details for the specified image lifecycle policy.
    ///
    /// Parameters:
    ///   - lifecyclePolicyArn: Specifies the Amazon Resource Name (ARN) of the image lifecycle policy resource to get.
    ///   - logger: Logger use during operation
    @inlinable
    public func getLifecyclePolicy(
        lifecyclePolicyArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetLifecyclePolicyResponse {
        let input = GetLifecyclePolicyRequest(
            lifecyclePolicyArn: lifecyclePolicyArn
        )
        return try await self.getLifecyclePolicy(input, logger: logger)
    }

    /// Verify the subscription and perform resource dependency checks on the requested
    /// 			Amazon Web Services Marketplace resource. For Amazon Web Services Marketplace components, the response contains fields to download the
    /// 			components and their artifacts.
    @Sendable
    @inlinable
    public func getMarketplaceResource(_ input: GetMarketplaceResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMarketplaceResourceResponse {
        try await self.client.execute(
            operation: "GetMarketplaceResource", 
            path: "/GetMarketplaceResource", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Verify the subscription and perform resource dependency checks on the requested
    /// 			Amazon Web Services Marketplace resource. For Amazon Web Services Marketplace components, the response contains fields to download the
    /// 			components and their artifacts.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) that uniquely identifies an Amazon Web Services Marketplace resource.
    ///   - resourceLocation: The bucket path that you can specify to download the resource from Amazon S3.
    ///   - resourceType: Specifies which type of Amazon Web Services Marketplace resource Image Builder retrieves.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMarketplaceResource(
        resourceArn: String,
        resourceLocation: String? = nil,
        resourceType: MarketplaceResourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMarketplaceResourceResponse {
        let input = GetMarketplaceResourceRequest(
            resourceArn: resourceArn, 
            resourceLocation: resourceLocation, 
            resourceType: resourceType
        )
        return try await self.getMarketplaceResource(input, logger: logger)
    }

    /// Get a workflow resource object.
    @Sendable
    @inlinable
    public func getWorkflow(_ input: GetWorkflowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWorkflowResponse {
        try await self.client.execute(
            operation: "GetWorkflow", 
            path: "/GetWorkflow", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get a workflow resource object.
    ///
    /// Parameters:
    ///   - workflowBuildVersionArn: The Amazon Resource Name (ARN) of the workflow resource that you want to get.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWorkflow(
        workflowBuildVersionArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWorkflowResponse {
        let input = GetWorkflowRequest(
            workflowBuildVersionArn: workflowBuildVersionArn
        )
        return try await self.getWorkflow(input, logger: logger)
    }

    /// Get the runtime information that was logged for a specific runtime instance
    /// 			of the workflow.
    @Sendable
    @inlinable
    public func getWorkflowExecution(_ input: GetWorkflowExecutionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWorkflowExecutionResponse {
        try await self.client.execute(
            operation: "GetWorkflowExecution", 
            path: "/GetWorkflowExecution", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the runtime information that was logged for a specific runtime instance
    /// 			of the workflow.
    ///
    /// Parameters:
    ///   - workflowExecutionId: Use the unique identifier for a runtime instance of the workflow to get
    ///   - logger: Logger use during operation
    @inlinable
    public func getWorkflowExecution(
        workflowExecutionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWorkflowExecutionResponse {
        let input = GetWorkflowExecutionRequest(
            workflowExecutionId: workflowExecutionId
        )
        return try await self.getWorkflowExecution(input, logger: logger)
    }

    /// Get the runtime information that was logged for a specific runtime instance of
    /// 			the workflow step.
    @Sendable
    @inlinable
    public func getWorkflowStepExecution(_ input: GetWorkflowStepExecutionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWorkflowStepExecutionResponse {
        try await self.client.execute(
            operation: "GetWorkflowStepExecution", 
            path: "/GetWorkflowStepExecution", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the runtime information that was logged for a specific runtime instance of
    /// 			the workflow step.
    ///
    /// Parameters:
    ///   - stepExecutionId: Use the unique identifier for a specific runtime instance of the workflow step to
    ///   - logger: Logger use during operation
    @inlinable
    public func getWorkflowStepExecution(
        stepExecutionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWorkflowStepExecutionResponse {
        let input = GetWorkflowStepExecutionRequest(
            stepExecutionId: stepExecutionId
        )
        return try await self.getWorkflowStepExecution(input, logger: logger)
    }

    /// Imports a component and transforms its data into a component document.
    @Sendable
    @inlinable
    public func importComponent(_ input: ImportComponentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ImportComponentResponse {
        try await self.client.execute(
            operation: "ImportComponent", 
            path: "/ImportComponent", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Imports a component and transforms its data into a component document.
    ///
    /// Parameters:
    ///   - changeDescription: The change description of the component. This description indicates the change that
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - data: The data of the component. Used to specify the data inline. Either data
    ///   - description: The description of the component. Describes the contents of the component.
    ///   - format: The format of the resource that you want to import as a component.
    ///   - kmsKeyId: The Amazon Resource Name (ARN) that uniquely identifies the KMS key used to encrypt this component. This can be either the Key ARN or the Alias ARN. For more information, see Key identifiers (KeyId)
    ///   - name: The name of the component.
    ///   - platform: The platform of the component.
    ///   - semanticVersion: The semantic version of the component. This version follows the semantic version
    ///   - tags: The tags of the component.
    ///   - type: The type of the component denotes whether the component is used to build the image, or
    ///   - uri: The uri of the component. Must be an Amazon S3 URL and the requester must have permission
    ///   - logger: Logger use during operation
    @inlinable
    public func importComponent(
        changeDescription: String? = nil,
        clientToken: String = ImportComponentRequest.idempotencyToken(),
        data: String? = nil,
        description: String? = nil,
        format: ComponentFormat,
        kmsKeyId: String? = nil,
        name: String,
        platform: Platform,
        semanticVersion: String,
        tags: [String: String]? = nil,
        type: ComponentType,
        uri: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ImportComponentResponse {
        let input = ImportComponentRequest(
            changeDescription: changeDescription, 
            clientToken: clientToken, 
            data: data, 
            description: description, 
            format: format, 
            kmsKeyId: kmsKeyId, 
            name: name, 
            platform: platform, 
            semanticVersion: semanticVersion, 
            tags: tags, 
            type: type, 
            uri: uri
        )
        return try await self.importComponent(input, logger: logger)
    }

    /// Import a Windows operating system image from a verified Microsoft ISO disk
    /// 			file. The following disk images are supported:   Windows 11 Enterprise
    @Sendable
    @inlinable
    public func importDiskImage(_ input: ImportDiskImageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ImportDiskImageResponse {
        try await self.client.execute(
            operation: "ImportDiskImage", 
            path: "/ImportDiskImage", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Import a Windows operating system image from a verified Microsoft ISO disk
    /// 			file. The following disk images are supported:   Windows 11 Enterprise
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - description: The description for your disk image import.
    ///   - executionRole: The name or Amazon Resource Name (ARN) for the IAM role you create that grants Image Builder access
    ///   - infrastructureConfigurationArn: The Amazon Resource Name (ARN) of the infrastructure configuration resource that's used for
    ///   - loggingConfiguration: Define logging configuration for the image build process.
    ///   - name: The name of the image resource that's created from the import.
    ///   - osVersion: The operating system version for the imported image. Allowed values include
    ///   - platform: The operating system platform for the imported image. Allowed values include
    ///   - semanticVersion: The semantic version to attach to the image that's created during the import
    ///   - tags: Tags that are attached to image resources created from the import.
    ///   - uri: The uri of the ISO disk file that's stored in Amazon S3.
    ///   - logger: Logger use during operation
    @inlinable
    public func importDiskImage(
        clientToken: String = ImportDiskImageRequest.idempotencyToken(),
        description: String? = nil,
        executionRole: String? = nil,
        infrastructureConfigurationArn: String,
        loggingConfiguration: ImageLoggingConfiguration? = nil,
        name: String,
        osVersion: String,
        platform: String,
        semanticVersion: String,
        tags: [String: String]? = nil,
        uri: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ImportDiskImageResponse {
        let input = ImportDiskImageRequest(
            clientToken: clientToken, 
            description: description, 
            executionRole: executionRole, 
            infrastructureConfigurationArn: infrastructureConfigurationArn, 
            loggingConfiguration: loggingConfiguration, 
            name: name, 
            osVersion: osVersion, 
            platform: platform, 
            semanticVersion: semanticVersion, 
            tags: tags, 
            uri: uri
        )
        return try await self.importDiskImage(input, logger: logger)
    }

    /// When you export your virtual machine (VM) from its virtualization environment, that
    /// 			process creates a set of one or more disk container files that act as snapshots of your
    /// 			VM’s environment, settings, and data. The Amazon EC2 API ImportImage
    /// 			action uses those files to import your VM and create an AMI. To import using the CLI
    /// 			command, see import-image  You can reference the task ID from the VM import to pull in the AMI that the import
    /// 			created as the base image for your Image Builder recipe.
    @Sendable
    @inlinable
    public func importVmImage(_ input: ImportVmImageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ImportVmImageResponse {
        try await self.client.execute(
            operation: "ImportVmImage", 
            path: "/ImportVmImage", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// When you export your virtual machine (VM) from its virtualization environment, that
    /// 			process creates a set of one or more disk container files that act as snapshots of your
    /// 			VM’s environment, settings, and data. The Amazon EC2 API ImportImage
    /// 			action uses those files to import your VM and create an AMI. To import using the CLI
    /// 			command, see import-image  You can reference the task ID from the VM import to pull in the AMI that the import
    /// 			created as the base image for your Image Builder recipe.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - description: The description for the base image that is created by the import process.
    ///   - loggingConfiguration: Define logging configuration for the image build process.
    ///   - name: The name of the base image that is created by the import process.
    ///   - osVersion: The operating system version for the imported VM.
    ///   - platform: The operating system platform for the imported VM.
    ///   - semanticVersion: The semantic version to attach to the base image that was created during the import
    ///   - tags: Tags that are attached to the import resources.
    ///   - vmImportTaskId: The importTaskId (API) or ImportTaskId (CLI) from the
    ///   - logger: Logger use during operation
    @inlinable
    public func importVmImage(
        clientToken: String = ImportVmImageRequest.idempotencyToken(),
        description: String? = nil,
        loggingConfiguration: ImageLoggingConfiguration? = nil,
        name: String,
        osVersion: String? = nil,
        platform: Platform,
        semanticVersion: String,
        tags: [String: String]? = nil,
        vmImportTaskId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ImportVmImageResponse {
        let input = ImportVmImageRequest(
            clientToken: clientToken, 
            description: description, 
            loggingConfiguration: loggingConfiguration, 
            name: name, 
            osVersion: osVersion, 
            platform: platform, 
            semanticVersion: semanticVersion, 
            tags: tags, 
            vmImportTaskId: vmImportTaskId
        )
        return try await self.importVmImage(input, logger: logger)
    }

    /// Returns the list of component build versions for the specified component
    /// 			version Amazon Resource Name (ARN).
    @Sendable
    @inlinable
    public func listComponentBuildVersions(_ input: ListComponentBuildVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListComponentBuildVersionsResponse {
        try await self.client.execute(
            operation: "ListComponentBuildVersions", 
            path: "/ListComponentBuildVersions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the list of component build versions for the specified component
    /// 			version Amazon Resource Name (ARN).
    ///
    /// Parameters:
    ///   - componentVersionArn: The component version Amazon Resource Name (ARN) whose versions you want to
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - logger: Logger use during operation
    @inlinable
    public func listComponentBuildVersions(
        componentVersionArn: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListComponentBuildVersionsResponse {
        let input = ListComponentBuildVersionsRequest(
            componentVersionArn: componentVersionArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listComponentBuildVersions(input, logger: logger)
    }

    /// Returns the list of components that can be filtered by name, or by using the listed
    /// 				filters to streamline results. Newly created components can take up to
    /// 			two minutes to appear in the ListComponents API Results.  The semantic version has four nodes: ../.
    /// 	You can assign values for the first three, and can filter on all of them.  Filtering: With semantic versioning, you have the flexibility to use wildcards (x)
    /// 	to specify the most recent versions or nodes when selecting the base image or components for your
    /// 	recipe. When you use a wildcard in any node, all nodes to the right of the first wildcard must also be
    /// 	wildcards.
    @Sendable
    @inlinable
    public func listComponents(_ input: ListComponentsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListComponentsResponse {
        try await self.client.execute(
            operation: "ListComponents", 
            path: "/ListComponents", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the list of components that can be filtered by name, or by using the listed
    /// 				filters to streamline results. Newly created components can take up to
    /// 			two minutes to appear in the ListComponents API Results.  The semantic version has four nodes: ../.
    /// 	You can assign values for the first three, and can filter on all of them.  Filtering: With semantic versioning, you have the flexibility to use wildcards (x)
    /// 	to specify the most recent versions or nodes when selecting the base image or components for your
    /// 	recipe. When you use a wildcard in any node, all nodes to the right of the first wildcard must also be
    /// 	wildcards.
    ///
    /// Parameters:
    ///   - byName: Returns the list of components for the specified name.
    ///   - filters: Use the following filters to streamline results:    description     name     platform     supportedOsVersion     type     version
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - owner: Filters results based on the type of owner for the component. By default, this request
    ///   - logger: Logger use during operation
    @inlinable
    public func listComponents(
        byName: Bool? = nil,
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        owner: Ownership? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListComponentsResponse {
        let input = ListComponentsRequest(
            byName: byName, 
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            owner: owner
        )
        return try await self.listComponents(input, logger: logger)
    }

    /// Returns a list of container recipes.
    @Sendable
    @inlinable
    public func listContainerRecipes(_ input: ListContainerRecipesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListContainerRecipesResponse {
        try await self.client.execute(
            operation: "ListContainerRecipes", 
            path: "/ListContainerRecipes", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of container recipes.
    ///
    /// Parameters:
    ///   - filters: Use the following filters to streamline results:    containerType     name     parentImage     platform
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - owner: Returns container recipes belonging to the specified owner, that have been shared with
    ///   - logger: Logger use during operation
    @inlinable
    public func listContainerRecipes(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        owner: Ownership? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListContainerRecipesResponse {
        let input = ListContainerRecipesRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            owner: owner
        )
        return try await self.listContainerRecipes(input, logger: logger)
    }

    /// Returns a list of distribution configurations.
    @Sendable
    @inlinable
    public func listDistributionConfigurations(_ input: ListDistributionConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDistributionConfigurationsResponse {
        try await self.client.execute(
            operation: "ListDistributionConfigurations", 
            path: "/ListDistributionConfigurations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of distribution configurations.
    ///
    /// Parameters:
    ///   - filters: You can filter on name to streamline results.
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - logger: Logger use during operation
    @inlinable
    public func listDistributionConfigurations(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDistributionConfigurationsResponse {
        let input = ListDistributionConfigurationsRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDistributionConfigurations(input, logger: logger)
    }

    /// Returns a list of image build versions.
    @Sendable
    @inlinable
    public func listImageBuildVersions(_ input: ListImageBuildVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListImageBuildVersionsResponse {
        try await self.client.execute(
            operation: "ListImageBuildVersions", 
            path: "/ListImageBuildVersions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of image build versions.
    ///
    /// Parameters:
    ///   - filters: Use the following filters to streamline results:    name     osVersion     platform     type     version
    ///   - imageVersionArn: The Amazon Resource Name (ARN) of the image whose build versions you want to
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - logger: Logger use during operation
    @inlinable
    public func listImageBuildVersions(
        filters: [Filter]? = nil,
        imageVersionArn: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListImageBuildVersionsResponse {
        let input = ListImageBuildVersionsRequest(
            filters: filters, 
            imageVersionArn: imageVersionArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listImageBuildVersions(input, logger: logger)
    }

    /// List the Packages that are associated with an Image Build Version, as determined by
    /// 			Amazon Web Services Systems Manager Inventory at build time.
    @Sendable
    @inlinable
    public func listImagePackages(_ input: ListImagePackagesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListImagePackagesResponse {
        try await self.client.execute(
            operation: "ListImagePackages", 
            path: "/ListImagePackages", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List the Packages that are associated with an Image Build Version, as determined by
    /// 			Amazon Web Services Systems Manager Inventory at build time.
    ///
    /// Parameters:
    ///   - imageBuildVersionArn: Filter results for the ListImagePackages request by the Image Build Version ARN
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - logger: Logger use during operation
    @inlinable
    public func listImagePackages(
        imageBuildVersionArn: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListImagePackagesResponse {
        let input = ListImagePackagesRequest(
            imageBuildVersionArn: imageBuildVersionArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listImagePackages(input, logger: logger)
    }

    /// Returns a list of images created by the specified pipeline.
    @Sendable
    @inlinable
    public func listImagePipelineImages(_ input: ListImagePipelineImagesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListImagePipelineImagesResponse {
        try await self.client.execute(
            operation: "ListImagePipelineImages", 
            path: "/ListImagePipelineImages", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of images created by the specified pipeline.
    ///
    /// Parameters:
    ///   - filters: Use the following filters to streamline results:    name     version
    ///   - imagePipelineArn: The Amazon Resource Name (ARN) of the image pipeline whose images you want to
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - logger: Logger use during operation
    @inlinable
    public func listImagePipelineImages(
        filters: [Filter]? = nil,
        imagePipelineArn: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListImagePipelineImagesResponse {
        let input = ListImagePipelineImagesRequest(
            filters: filters, 
            imagePipelineArn: imagePipelineArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listImagePipelineImages(input, logger: logger)
    }

    /// Returns a list of image pipelines.
    @Sendable
    @inlinable
    public func listImagePipelines(_ input: ListImagePipelinesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListImagePipelinesResponse {
        try await self.client.execute(
            operation: "ListImagePipelines", 
            path: "/ListImagePipelines", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of image pipelines.
    ///
    /// Parameters:
    ///   - filters: Use the following filters to streamline results:    description     distributionConfigurationArn     imageRecipeArn     infrastructureConfigurationArn     name     status
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - logger: Logger use during operation
    @inlinable
    public func listImagePipelines(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListImagePipelinesResponse {
        let input = ListImagePipelinesRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listImagePipelines(input, logger: logger)
    }

    /// Returns a list of image recipes.
    @Sendable
    @inlinable
    public func listImageRecipes(_ input: ListImageRecipesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListImageRecipesResponse {
        try await self.client.execute(
            operation: "ListImageRecipes", 
            path: "/ListImageRecipes", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of image recipes.
    ///
    /// Parameters:
    ///   - filters: Use the following filters to streamline results:    name     parentImage     platform
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - owner: You can specify the recipe owner to filter results by that owner. By default, this request will
    ///   - logger: Logger use during operation
    @inlinable
    public func listImageRecipes(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        owner: Ownership? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListImageRecipesResponse {
        let input = ListImageRecipesRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            owner: owner
        )
        return try await self.listImageRecipes(input, logger: logger)
    }

    /// Returns a list of image scan aggregations for your account. You can filter by the type
    /// 			of key that Image Builder uses to group results. For example, if you want to get a list of
    /// 			findings by severity level for one of your pipelines, you might specify your pipeline
    /// 			with the imagePipelineArn filter. If you don't specify a filter, Image Builder
    /// 			returns an aggregation for your account. To streamline results, you can use the following filters in your request:    accountId     imageBuildVersionArn     imagePipelineArn     vulnerabilityId
    @Sendable
    @inlinable
    public func listImageScanFindingAggregations(_ input: ListImageScanFindingAggregationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListImageScanFindingAggregationsResponse {
        try await self.client.execute(
            operation: "ListImageScanFindingAggregations", 
            path: "/ListImageScanFindingAggregations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of image scan aggregations for your account. You can filter by the type
    /// 			of key that Image Builder uses to group results. For example, if you want to get a list of
    /// 			findings by severity level for one of your pipelines, you might specify your pipeline
    /// 			with the imagePipelineArn filter. If you don't specify a filter, Image Builder
    /// 			returns an aggregation for your account. To streamline results, you can use the following filters in your request:    accountId     imageBuildVersionArn     imagePipelineArn     vulnerabilityId
    ///
    /// Parameters:
    ///   - filter: 
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - logger: Logger use during operation
    @inlinable
    public func listImageScanFindingAggregations(
        filter: Filter? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListImageScanFindingAggregationsResponse {
        let input = ListImageScanFindingAggregationsRequest(
            filter: filter, 
            nextToken: nextToken
        )
        return try await self.listImageScanFindingAggregations(input, logger: logger)
    }

    /// Returns a list of image scan findings for your account.
    @Sendable
    @inlinable
    public func listImageScanFindings(_ input: ListImageScanFindingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListImageScanFindingsResponse {
        try await self.client.execute(
            operation: "ListImageScanFindings", 
            path: "/ListImageScanFindings", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of image scan findings for your account.
    ///
    /// Parameters:
    ///   - filters: An array of name value pairs that you can use to filter your results. You can use the
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - logger: Logger use during operation
    @inlinable
    public func listImageScanFindings(
        filters: [ImageScanFindingsFilter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListImageScanFindingsResponse {
        let input = ListImageScanFindingsRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listImageScanFindings(input, logger: logger)
    }

    /// Returns the list of images that you have access to. Newly created images can take up
    /// 			to two minutes to appear in the ListImages API Results.
    @Sendable
    @inlinable
    public func listImages(_ input: ListImagesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListImagesResponse {
        try await self.client.execute(
            operation: "ListImages", 
            path: "/ListImages", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the list of images that you have access to. Newly created images can take up
    /// 			to two minutes to appear in the ListImages API Results.
    ///
    /// Parameters:
    ///   - byName: Requests a list of images with a specific recipe name.
    ///   - filters: Use the following filters to streamline results:    name     osVersion     platform     type     version
    ///   - includeDeprecated: Includes deprecated images in the response list.
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - owner: The owner defines which images you want to list. By default, this request will only
    ///   - logger: Logger use during operation
    @inlinable
    public func listImages(
        byName: Bool? = nil,
        filters: [Filter]? = nil,
        includeDeprecated: Bool? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        owner: Ownership? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListImagesResponse {
        let input = ListImagesRequest(
            byName: byName, 
            filters: filters, 
            includeDeprecated: includeDeprecated, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            owner: owner
        )
        return try await self.listImages(input, logger: logger)
    }

    /// Returns a list of infrastructure configurations.
    @Sendable
    @inlinable
    public func listInfrastructureConfigurations(_ input: ListInfrastructureConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListInfrastructureConfigurationsResponse {
        try await self.client.execute(
            operation: "ListInfrastructureConfigurations", 
            path: "/ListInfrastructureConfigurations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of infrastructure configurations.
    ///
    /// Parameters:
    ///   - filters: You can filter on name to streamline results.
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - logger: Logger use during operation
    @inlinable
    public func listInfrastructureConfigurations(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListInfrastructureConfigurationsResponse {
        let input = ListInfrastructureConfigurationsRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listInfrastructureConfigurations(input, logger: logger)
    }

    /// List resources that the runtime instance of the image lifecycle identified for lifecycle actions.
    @Sendable
    @inlinable
    public func listLifecycleExecutionResources(_ input: ListLifecycleExecutionResourcesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListLifecycleExecutionResourcesResponse {
        try await self.client.execute(
            operation: "ListLifecycleExecutionResources", 
            path: "/ListLifecycleExecutionResources", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List resources that the runtime instance of the image lifecycle identified for lifecycle actions.
    ///
    /// Parameters:
    ///   - lifecycleExecutionId: Use the unique identifier for a runtime instance of the lifecycle policy to get runtime details.
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - parentResourceId: You can  leave this empty to get a list of Image Builder resources that were identified for lifecycle actions. To get a list of associated resources that are impacted for an individual resource (the parent), specify
    ///   - logger: Logger use during operation
    @inlinable
    public func listLifecycleExecutionResources(
        lifecycleExecutionId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        parentResourceId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListLifecycleExecutionResourcesResponse {
        let input = ListLifecycleExecutionResourcesRequest(
            lifecycleExecutionId: lifecycleExecutionId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            parentResourceId: parentResourceId
        )
        return try await self.listLifecycleExecutionResources(input, logger: logger)
    }

    /// Get the lifecycle runtime history for the specified resource.
    @Sendable
    @inlinable
    public func listLifecycleExecutions(_ input: ListLifecycleExecutionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListLifecycleExecutionsResponse {
        try await self.client.execute(
            operation: "ListLifecycleExecutions", 
            path: "/ListLifecycleExecutions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the lifecycle runtime history for the specified resource.
    ///
    /// Parameters:
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource for which to get a list of lifecycle runtime instances.
    ///   - logger: Logger use during operation
    @inlinable
    public func listLifecycleExecutions(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListLifecycleExecutionsResponse {
        let input = ListLifecycleExecutionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceArn: resourceArn
        )
        return try await self.listLifecycleExecutions(input, logger: logger)
    }

    /// Get a list of lifecycle policies in your Amazon Web Services account.
    @Sendable
    @inlinable
    public func listLifecyclePolicies(_ input: ListLifecyclePoliciesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListLifecyclePoliciesResponse {
        try await self.client.execute(
            operation: "ListLifecyclePolicies", 
            path: "/ListLifecyclePolicies", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get a list of lifecycle policies in your Amazon Web Services account.
    ///
    /// Parameters:
    ///   - filters: Streamline results based on one of the following values: Name,
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - logger: Logger use during operation
    @inlinable
    public func listLifecyclePolicies(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListLifecyclePoliciesResponse {
        let input = ListLifecyclePoliciesRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listLifecyclePolicies(input, logger: logger)
    }

    /// Returns the list of tags for the specified resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the list of tags for the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource whose tags you want to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Get a list of workflow steps that are waiting for action for workflows
    /// 			in your Amazon Web Services account.
    @Sendable
    @inlinable
    public func listWaitingWorkflowSteps(_ input: ListWaitingWorkflowStepsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWaitingWorkflowStepsResponse {
        try await self.client.execute(
            operation: "ListWaitingWorkflowSteps", 
            path: "/ListWaitingWorkflowSteps", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get a list of workflow steps that are waiting for action for workflows
    /// 			in your Amazon Web Services account.
    ///
    /// Parameters:
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - logger: Logger use during operation
    @inlinable
    public func listWaitingWorkflowSteps(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWaitingWorkflowStepsResponse {
        let input = ListWaitingWorkflowStepsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listWaitingWorkflowSteps(input, logger: logger)
    }

    /// Returns a list of build versions for a specific workflow resource.
    @Sendable
    @inlinable
    public func listWorkflowBuildVersions(_ input: ListWorkflowBuildVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWorkflowBuildVersionsResponse {
        try await self.client.execute(
            operation: "ListWorkflowBuildVersions", 
            path: "/ListWorkflowBuildVersions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of build versions for a specific workflow resource.
    ///
    /// Parameters:
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - workflowVersionArn: The Amazon Resource Name (ARN) of the workflow resource for which to get a list of build versions.
    ///   - logger: Logger use during operation
    @inlinable
    public func listWorkflowBuildVersions(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        workflowVersionArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWorkflowBuildVersionsResponse {
        let input = ListWorkflowBuildVersionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            workflowVersionArn: workflowVersionArn
        )
        return try await self.listWorkflowBuildVersions(input, logger: logger)
    }

    /// Returns a list of workflow runtime instance metadata objects for a specific image build
    /// 			version.
    @Sendable
    @inlinable
    public func listWorkflowExecutions(_ input: ListWorkflowExecutionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWorkflowExecutionsResponse {
        try await self.client.execute(
            operation: "ListWorkflowExecutions", 
            path: "/ListWorkflowExecutions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of workflow runtime instance metadata objects for a specific image build
    /// 			version.
    ///
    /// Parameters:
    ///   - imageBuildVersionArn: List all workflow runtime instances for the specified image build version
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - logger: Logger use during operation
    @inlinable
    public func listWorkflowExecutions(
        imageBuildVersionArn: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWorkflowExecutionsResponse {
        let input = ListWorkflowExecutionsRequest(
            imageBuildVersionArn: imageBuildVersionArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listWorkflowExecutions(input, logger: logger)
    }

    /// Returns runtime data for each step in a runtime instance of the workflow
    /// 			that you specify in the request.
    @Sendable
    @inlinable
    public func listWorkflowStepExecutions(_ input: ListWorkflowStepExecutionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWorkflowStepExecutionsResponse {
        try await self.client.execute(
            operation: "ListWorkflowStepExecutions", 
            path: "/ListWorkflowStepExecutions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns runtime data for each step in a runtime instance of the workflow
    /// 			that you specify in the request.
    ///
    /// Parameters:
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - workflowExecutionId: The unique identifier that Image Builder assigned to keep track of runtime details
    ///   - logger: Logger use during operation
    @inlinable
    public func listWorkflowStepExecutions(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        workflowExecutionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWorkflowStepExecutionsResponse {
        let input = ListWorkflowStepExecutionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            workflowExecutionId: workflowExecutionId
        )
        return try await self.listWorkflowStepExecutions(input, logger: logger)
    }

    /// Lists workflow build versions based on filtering parameters.
    @Sendable
    @inlinable
    public func listWorkflows(_ input: ListWorkflowsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWorkflowsResponse {
        try await self.client.execute(
            operation: "ListWorkflows", 
            path: "/ListWorkflows", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists workflow build versions based on filtering parameters.
    ///
    /// Parameters:
    ///   - byName: Specify all or part of the workflow name to streamline results.
    ///   - filters: Used to streamline search results.
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - nextToken: A token to specify where to start paginating. This is the nextToken
    ///   - owner: Used to get a list of workflow build version filtered by the identity of the creator.
    ///   - logger: Logger use during operation
    @inlinable
    public func listWorkflows(
        byName: Bool? = nil,
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        owner: Ownership? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWorkflowsResponse {
        let input = ListWorkflowsRequest(
            byName: byName, 
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            owner: owner
        )
        return try await self.listWorkflows(input, logger: logger)
    }

    /// Applies a policy to a component. We recommend that you call the RAM API CreateResourceShare to share resources. If you call the Image Builder API
    /// 				PutComponentPolicy, you must also call the RAM API PromoteResourceShareCreatedFromPolicy in order for the resource to be
    /// 			visible to all principals with whom the resource is shared.
    @Sendable
    @inlinable
    public func putComponentPolicy(_ input: PutComponentPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutComponentPolicyResponse {
        try await self.client.execute(
            operation: "PutComponentPolicy", 
            path: "/PutComponentPolicy", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Applies a policy to a component. We recommend that you call the RAM API CreateResourceShare to share resources. If you call the Image Builder API
    /// 				PutComponentPolicy, you must also call the RAM API PromoteResourceShareCreatedFromPolicy in order for the resource to be
    /// 			visible to all principals with whom the resource is shared.
    ///
    /// Parameters:
    ///   - componentArn: The Amazon Resource Name (ARN) of the component that this policy should be applied
    ///   - policy: The policy to apply.
    ///   - logger: Logger use during operation
    @inlinable
    public func putComponentPolicy(
        componentArn: String,
        policy: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutComponentPolicyResponse {
        let input = PutComponentPolicyRequest(
            componentArn: componentArn, 
            policy: policy
        )
        return try await self.putComponentPolicy(input, logger: logger)
    }

    /// Applies a policy to a container image. We recommend that you call the RAM API
    /// 			CreateResourceShare
    /// 			(https://docs.aws.amazon.com//ram/latest/APIReference/API_CreateResourceShare.html) to share
    /// 			resources. If you call the Image Builder API PutContainerImagePolicy, you must also
    /// 			call the RAM API PromoteResourceShareCreatedFromPolicy
    /// 			(https://docs.aws.amazon.com//ram/latest/APIReference/API_PromoteResourceShareCreatedFromPolicy.html)
    /// 			in order for the resource to be visible to all principals with whom the resource is
    /// 			shared.
    @Sendable
    @inlinable
    public func putContainerRecipePolicy(_ input: PutContainerRecipePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutContainerRecipePolicyResponse {
        try await self.client.execute(
            operation: "PutContainerRecipePolicy", 
            path: "/PutContainerRecipePolicy", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Applies a policy to a container image. We recommend that you call the RAM API
    /// 			CreateResourceShare
    /// 			(https://docs.aws.amazon.com//ram/latest/APIReference/API_CreateResourceShare.html) to share
    /// 			resources. If you call the Image Builder API PutContainerImagePolicy, you must also
    /// 			call the RAM API PromoteResourceShareCreatedFromPolicy
    /// 			(https://docs.aws.amazon.com//ram/latest/APIReference/API_PromoteResourceShareCreatedFromPolicy.html)
    /// 			in order for the resource to be visible to all principals with whom the resource is
    /// 			shared.
    ///
    /// Parameters:
    ///   - containerRecipeArn: The Amazon Resource Name (ARN) of the container recipe that this policy should be
    ///   - policy: The policy to apply to the container recipe.
    ///   - logger: Logger use during operation
    @inlinable
    public func putContainerRecipePolicy(
        containerRecipeArn: String,
        policy: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutContainerRecipePolicyResponse {
        let input = PutContainerRecipePolicyRequest(
            containerRecipeArn: containerRecipeArn, 
            policy: policy
        )
        return try await self.putContainerRecipePolicy(input, logger: logger)
    }

    /// Applies a policy to an image. We recommend that you call the RAM API CreateResourceShare to share resources. If you call the Image Builder API
    /// 				PutImagePolicy, you must also call the RAM API PromoteResourceShareCreatedFromPolicy in order for the resource to be
    /// 			visible to all principals with whom the resource is shared.
    @Sendable
    @inlinable
    public func putImagePolicy(_ input: PutImagePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutImagePolicyResponse {
        try await self.client.execute(
            operation: "PutImagePolicy", 
            path: "/PutImagePolicy", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Applies a policy to an image. We recommend that you call the RAM API CreateResourceShare to share resources. If you call the Image Builder API
    /// 				PutImagePolicy, you must also call the RAM API PromoteResourceShareCreatedFromPolicy in order for the resource to be
    /// 			visible to all principals with whom the resource is shared.
    ///
    /// Parameters:
    ///   - imageArn: The Amazon Resource Name (ARN) of the image that this policy should be applied
    ///   - policy: The policy to apply.
    ///   - logger: Logger use during operation
    @inlinable
    public func putImagePolicy(
        imageArn: String,
        policy: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutImagePolicyResponse {
        let input = PutImagePolicyRequest(
            imageArn: imageArn, 
            policy: policy
        )
        return try await self.putImagePolicy(input, logger: logger)
    }

    /// Applies a policy to an image recipe. We recommend that you call the RAM API CreateResourceShare to share resources. If you call the Image Builder API
    /// 				PutImageRecipePolicy, you must also call the RAM API PromoteResourceShareCreatedFromPolicy in order for the resource to be
    /// 			visible to all principals with whom the resource is shared.
    @Sendable
    @inlinable
    public func putImageRecipePolicy(_ input: PutImageRecipePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutImageRecipePolicyResponse {
        try await self.client.execute(
            operation: "PutImageRecipePolicy", 
            path: "/PutImageRecipePolicy", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Applies a policy to an image recipe. We recommend that you call the RAM API CreateResourceShare to share resources. If you call the Image Builder API
    /// 				PutImageRecipePolicy, you must also call the RAM API PromoteResourceShareCreatedFromPolicy in order for the resource to be
    /// 			visible to all principals with whom the resource is shared.
    ///
    /// Parameters:
    ///   - imageRecipeArn: The Amazon Resource Name (ARN) of the image recipe that this policy should be applied
    ///   - policy: The policy to apply.
    ///   - logger: Logger use during operation
    @inlinable
    public func putImageRecipePolicy(
        imageRecipeArn: String,
        policy: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutImageRecipePolicyResponse {
        let input = PutImageRecipePolicyRequest(
            imageRecipeArn: imageRecipeArn, 
            policy: policy
        )
        return try await self.putImageRecipePolicy(input, logger: logger)
    }

    /// Pauses or resumes image creation when the associated workflow runs a
    /// 			WaitForAction step.
    @Sendable
    @inlinable
    public func sendWorkflowStepAction(_ input: SendWorkflowStepActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendWorkflowStepActionResponse {
        try await self.client.execute(
            operation: "SendWorkflowStepAction", 
            path: "/SendWorkflowStepAction", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Pauses or resumes image creation when the associated workflow runs a
    /// 			WaitForAction step.
    ///
    /// Parameters:
    ///   - action: The action for the image creation process to take while a workflow
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - imageBuildVersionArn: The Amazon Resource Name (ARN) of the image build version to send action for.
    ///   - reason: The reason why this action is sent.
    ///   - stepExecutionId: Uniquely identifies the workflow step that sent the step action.
    ///   - logger: Logger use during operation
    @inlinable
    public func sendWorkflowStepAction(
        action: WorkflowStepActionType,
        clientToken: String = SendWorkflowStepActionRequest.idempotencyToken(),
        imageBuildVersionArn: String,
        reason: String? = nil,
        stepExecutionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendWorkflowStepActionResponse {
        let input = SendWorkflowStepActionRequest(
            action: action, 
            clientToken: clientToken, 
            imageBuildVersionArn: imageBuildVersionArn, 
            reason: reason, 
            stepExecutionId: stepExecutionId
        )
        return try await self.sendWorkflowStepAction(input, logger: logger)
    }

    /// Manually triggers a pipeline to create an image.
    @Sendable
    @inlinable
    public func startImagePipelineExecution(_ input: StartImagePipelineExecutionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartImagePipelineExecutionResponse {
        try await self.client.execute(
            operation: "StartImagePipelineExecution", 
            path: "/StartImagePipelineExecution", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Manually triggers a pipeline to create an image.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - imagePipelineArn: The Amazon Resource Name (ARN) of the image pipeline that you want to manually
    ///   - tags: Specify tags for Image Builder to apply to the image resource that's created
    ///   - logger: Logger use during operation
    @inlinable
    public func startImagePipelineExecution(
        clientToken: String = StartImagePipelineExecutionRequest.idempotencyToken(),
        imagePipelineArn: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartImagePipelineExecutionResponse {
        let input = StartImagePipelineExecutionRequest(
            clientToken: clientToken, 
            imagePipelineArn: imagePipelineArn, 
            tags: tags
        )
        return try await self.startImagePipelineExecution(input, logger: logger)
    }

    /// Begin asynchronous resource state update for lifecycle changes to the
    /// 			specified image resources.
    @Sendable
    @inlinable
    public func startResourceStateUpdate(_ input: StartResourceStateUpdateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartResourceStateUpdateResponse {
        try await self.client.execute(
            operation: "StartResourceStateUpdate", 
            path: "/StartResourceStateUpdate", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Begin asynchronous resource state update for lifecycle changes to the
    /// 			specified image resources.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - exclusionRules: Skip action on the image resource and associated resources if specified
    ///   - executionRole: The name or Amazon Resource Name (ARN) of the IAM role that’s used to update image state.
    ///   - includeResources: A list of image resources to update state for.
    ///   - resourceArn: The ARN of the Image Builder resource that is updated. The state update might also
    ///   - state: Indicates the lifecycle action to take for this request.
    ///   - updateAt: The timestamp that indicates when resources are updated by a lifecycle action.
    ///   - logger: Logger use during operation
    @inlinable
    public func startResourceStateUpdate(
        clientToken: String = StartResourceStateUpdateRequest.idempotencyToken(),
        exclusionRules: ResourceStateUpdateExclusionRules? = nil,
        executionRole: String? = nil,
        includeResources: ResourceStateUpdateIncludeResources? = nil,
        resourceArn: String,
        state: ResourceState,
        updateAt: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartResourceStateUpdateResponse {
        let input = StartResourceStateUpdateRequest(
            clientToken: clientToken, 
            exclusionRules: exclusionRules, 
            executionRole: executionRole, 
            includeResources: includeResources, 
            resourceArn: resourceArn, 
            state: state, 
            updateAt: updateAt
        )
        return try await self.startResourceStateUpdate(input, logger: logger)
    }

    /// Adds a tag to a resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds a tag to a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource that you want to tag.
    ///   - tags: The tags to apply to the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes a tag from a resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes a tag from a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource that you want to untag.
    ///   - tagKeys: The tag keys to remove from the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates a new distribution configuration. Distribution configurations define and
    /// 			configure the outputs of your pipeline.
    @Sendable
    @inlinable
    public func updateDistributionConfiguration(_ input: UpdateDistributionConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateDistributionConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateDistributionConfiguration", 
            path: "/UpdateDistributionConfiguration", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a new distribution configuration. Distribution configurations define and
    /// 			configure the outputs of your pipeline.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - description: The description of the distribution configuration.
    ///   - distributionConfigurationArn: The Amazon Resource Name (ARN) of the distribution configuration that you want to
    ///   - distributions: The distributions of the distribution configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDistributionConfiguration(
        clientToken: String = UpdateDistributionConfigurationRequest.idempotencyToken(),
        description: String? = nil,
        distributionConfigurationArn: String,
        distributions: [Distribution],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDistributionConfigurationResponse {
        let input = UpdateDistributionConfigurationRequest(
            clientToken: clientToken, 
            description: description, 
            distributionConfigurationArn: distributionConfigurationArn, 
            distributions: distributions
        )
        return try await self.updateDistributionConfiguration(input, logger: logger)
    }

    /// Updates an image pipeline. Image pipelines enable you to automate the creation and
    /// 			distribution of images. You must specify exactly one recipe for your image, using either
    /// 			a containerRecipeArn or an imageRecipeArn.  UpdateImagePipeline does not support selective updates for the pipeline. You must
    /// 				specify all of the required properties in the update request, not just the
    /// 				properties that have changed.
    @Sendable
    @inlinable
    public func updateImagePipeline(_ input: UpdateImagePipelineRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateImagePipelineResponse {
        try await self.client.execute(
            operation: "UpdateImagePipeline", 
            path: "/UpdateImagePipeline", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an image pipeline. Image pipelines enable you to automate the creation and
    /// 			distribution of images. You must specify exactly one recipe for your image, using either
    /// 			a containerRecipeArn or an imageRecipeArn.  UpdateImagePipeline does not support selective updates for the pipeline. You must
    /// 				specify all of the required properties in the update request, not just the
    /// 				properties that have changed.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - containerRecipeArn: The Amazon Resource Name (ARN) of the container pipeline to update.
    ///   - description: The description of the image pipeline.
    ///   - distributionConfigurationArn: The Amazon Resource Name (ARN) of the distribution configuration that Image Builder uses to
    ///   - enhancedImageMetadataEnabled: Collects additional information about the image being created, including the operating
    ///   - executionRole: The name or Amazon Resource Name (ARN) for the IAM role you create that grants
    ///   - imagePipelineArn: The Amazon Resource Name (ARN) of the image pipeline that you want to update.
    ///   - imageRecipeArn: The Amazon Resource Name (ARN) of the image recipe that will be used to configure
    ///   - imageScanningConfiguration: Contains settings for vulnerability scans.
    ///   - imageTestsConfiguration: The image test configuration of the image pipeline.
    ///   - infrastructureConfigurationArn: The Amazon Resource Name (ARN) of the infrastructure configuration that Image Builder uses to
    ///   - loggingConfiguration: Update logging configuration for the output image that's created when
    ///   - schedule: The schedule of the image pipeline.
    ///   - status: The status of the image pipeline.
    ///   - workflows: Contains the workflows to run for the pipeline.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateImagePipeline(
        clientToken: String = UpdateImagePipelineRequest.idempotencyToken(),
        containerRecipeArn: String? = nil,
        description: String? = nil,
        distributionConfigurationArn: String? = nil,
        enhancedImageMetadataEnabled: Bool? = nil,
        executionRole: String? = nil,
        imagePipelineArn: String,
        imageRecipeArn: String? = nil,
        imageScanningConfiguration: ImageScanningConfiguration? = nil,
        imageTestsConfiguration: ImageTestsConfiguration? = nil,
        infrastructureConfigurationArn: String,
        loggingConfiguration: PipelineLoggingConfiguration? = nil,
        schedule: Schedule? = nil,
        status: PipelineStatus? = nil,
        workflows: [WorkflowConfiguration]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateImagePipelineResponse {
        let input = UpdateImagePipelineRequest(
            clientToken: clientToken, 
            containerRecipeArn: containerRecipeArn, 
            description: description, 
            distributionConfigurationArn: distributionConfigurationArn, 
            enhancedImageMetadataEnabled: enhancedImageMetadataEnabled, 
            executionRole: executionRole, 
            imagePipelineArn: imagePipelineArn, 
            imageRecipeArn: imageRecipeArn, 
            imageScanningConfiguration: imageScanningConfiguration, 
            imageTestsConfiguration: imageTestsConfiguration, 
            infrastructureConfigurationArn: infrastructureConfigurationArn, 
            loggingConfiguration: loggingConfiguration, 
            schedule: schedule, 
            status: status, 
            workflows: workflows
        )
        return try await self.updateImagePipeline(input, logger: logger)
    }

    /// Updates a new infrastructure configuration. An infrastructure configuration defines
    /// 			the environment in which your image will be built and tested.
    @Sendable
    @inlinable
    public func updateInfrastructureConfiguration(_ input: UpdateInfrastructureConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateInfrastructureConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateInfrastructureConfiguration", 
            path: "/UpdateInfrastructureConfiguration", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a new infrastructure configuration. An infrastructure configuration defines
    /// 			the environment in which your image will be built and tested.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - description: The description of the infrastructure configuration.
    ///   - infrastructureConfigurationArn: The Amazon Resource Name (ARN) of the infrastructure configuration that you want to
    ///   - instanceMetadataOptions: The instance metadata options that you can set for the HTTP requests that pipeline
    ///   - instanceProfileName: The instance profile to associate with the instance used to customize your Amazon EC2
    ///   - instanceTypes: The instance types of the infrastructure configuration. You can specify one or more
    ///   - keyPair: The key pair of the infrastructure configuration. You can use this to log on to and
    ///   - logging: The logging configuration of the infrastructure configuration.
    ///   - placement: The instance placement settings that define where the instances that are launched
    ///   - resourceTags: The tags attached to the resource created by Image Builder.
    ///   - securityGroupIds: The security group IDs to associate with the instance used to customize your Amazon EC2
    ///   - snsTopicArn: The Amazon Resource Name (ARN) for the SNS topic to which we send image build event
    ///   - subnetId: The subnet ID to place the instance used to customize your Amazon EC2 AMI in.
    ///   - terminateInstanceOnFailure: The terminate instance on failure setting of the infrastructure configuration. Set to
    ///   - logger: Logger use during operation
    @inlinable
    public func updateInfrastructureConfiguration(
        clientToken: String = UpdateInfrastructureConfigurationRequest.idempotencyToken(),
        description: String? = nil,
        infrastructureConfigurationArn: String,
        instanceMetadataOptions: InstanceMetadataOptions? = nil,
        instanceProfileName: String,
        instanceTypes: [String]? = nil,
        keyPair: String? = nil,
        logging: Logging? = nil,
        placement: Placement? = nil,
        resourceTags: [String: String]? = nil,
        securityGroupIds: [String]? = nil,
        snsTopicArn: String? = nil,
        subnetId: String? = nil,
        terminateInstanceOnFailure: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateInfrastructureConfigurationResponse {
        let input = UpdateInfrastructureConfigurationRequest(
            clientToken: clientToken, 
            description: description, 
            infrastructureConfigurationArn: infrastructureConfigurationArn, 
            instanceMetadataOptions: instanceMetadataOptions, 
            instanceProfileName: instanceProfileName, 
            instanceTypes: instanceTypes, 
            keyPair: keyPair, 
            logging: logging, 
            placement: placement, 
            resourceTags: resourceTags, 
            securityGroupIds: securityGroupIds, 
            snsTopicArn: snsTopicArn, 
            subnetId: subnetId, 
            terminateInstanceOnFailure: terminateInstanceOnFailure
        )
        return try await self.updateInfrastructureConfiguration(input, logger: logger)
    }

    /// Update the specified lifecycle policy.
    @Sendable
    @inlinable
    public func updateLifecyclePolicy(_ input: UpdateLifecyclePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateLifecyclePolicyResponse {
        try await self.client.execute(
            operation: "UpdateLifecyclePolicy", 
            path: "/UpdateLifecyclePolicy", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update the specified lifecycle policy.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see Ensuring idempotency  in the Amazon EC2 API Reference.
    ///   - description: Optional description for the lifecycle policy.
    ///   - executionRole: The name or Amazon Resource Name (ARN) of the IAM role that Image Builder uses to update the
    ///   - lifecyclePolicyArn: The Amazon Resource Name (ARN) of the lifecycle policy resource.
    ///   - policyDetails: The configuration details for a lifecycle policy resource.
    ///   - resourceSelection: Selection criteria for resources that the lifecycle policy applies to.
    ///   - resourceType: The type of image resource that the lifecycle policy applies to.
    ///   - status: Indicates whether the lifecycle policy resource is enabled.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateLifecyclePolicy(
        clientToken: String = UpdateLifecyclePolicyRequest.idempotencyToken(),
        description: String? = nil,
        executionRole: String,
        lifecyclePolicyArn: String,
        policyDetails: [LifecyclePolicyDetail],
        resourceSelection: LifecyclePolicyResourceSelection,
        resourceType: LifecyclePolicyResourceType,
        status: LifecyclePolicyStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateLifecyclePolicyResponse {
        let input = UpdateLifecyclePolicyRequest(
            clientToken: clientToken, 
            description: description, 
            executionRole: executionRole, 
            lifecyclePolicyArn: lifecyclePolicyArn, 
            policyDetails: policyDetails, 
            resourceSelection: resourceSelection, 
            resourceType: resourceType, 
            status: status
        )
        return try await self.updateLifecyclePolicy(input, logger: logger)
    }
}

extension Imagebuilder {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Imagebuilder, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Imagebuilder {
    /// Return PaginatorSequence for operation ``listComponentBuildVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listComponentBuildVersionsPaginator(
        _ input: ListComponentBuildVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListComponentBuildVersionsRequest, ListComponentBuildVersionsResponse> {
        return .init(
            input: input,
            command: self.listComponentBuildVersions,
            inputKey: \ListComponentBuildVersionsRequest.nextToken,
            outputKey: \ListComponentBuildVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listComponentBuildVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - componentVersionArn: The component version Amazon Resource Name (ARN) whose versions you want to
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - logger: Logger used for logging
    @inlinable
    public func listComponentBuildVersionsPaginator(
        componentVersionArn: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListComponentBuildVersionsRequest, ListComponentBuildVersionsResponse> {
        let input = ListComponentBuildVersionsRequest(
            componentVersionArn: componentVersionArn, 
            maxResults: maxResults
        )
        return self.listComponentBuildVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listComponents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listComponentsPaginator(
        _ input: ListComponentsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListComponentsRequest, ListComponentsResponse> {
        return .init(
            input: input,
            command: self.listComponents,
            inputKey: \ListComponentsRequest.nextToken,
            outputKey: \ListComponentsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listComponents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - byName: Returns the list of components for the specified name.
    ///   - filters: Use the following filters to streamline results:    description     name     platform     supportedOsVersion     type     version
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - owner: Filters results based on the type of owner for the component. By default, this request
    ///   - logger: Logger used for logging
    @inlinable
    public func listComponentsPaginator(
        byName: Bool? = nil,
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        owner: Ownership? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListComponentsRequest, ListComponentsResponse> {
        let input = ListComponentsRequest(
            byName: byName, 
            filters: filters, 
            maxResults: maxResults, 
            owner: owner
        )
        return self.listComponentsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listContainerRecipes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listContainerRecipesPaginator(
        _ input: ListContainerRecipesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListContainerRecipesRequest, ListContainerRecipesResponse> {
        return .init(
            input: input,
            command: self.listContainerRecipes,
            inputKey: \ListContainerRecipesRequest.nextToken,
            outputKey: \ListContainerRecipesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listContainerRecipes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Use the following filters to streamline results:    containerType     name     parentImage     platform
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - owner: Returns container recipes belonging to the specified owner, that have been shared with
    ///   - logger: Logger used for logging
    @inlinable
    public func listContainerRecipesPaginator(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        owner: Ownership? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListContainerRecipesRequest, ListContainerRecipesResponse> {
        let input = ListContainerRecipesRequest(
            filters: filters, 
            maxResults: maxResults, 
            owner: owner
        )
        return self.listContainerRecipesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDistributionConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDistributionConfigurationsPaginator(
        _ input: ListDistributionConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDistributionConfigurationsRequest, ListDistributionConfigurationsResponse> {
        return .init(
            input: input,
            command: self.listDistributionConfigurations,
            inputKey: \ListDistributionConfigurationsRequest.nextToken,
            outputKey: \ListDistributionConfigurationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDistributionConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: You can filter on name to streamline results.
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDistributionConfigurationsPaginator(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDistributionConfigurationsRequest, ListDistributionConfigurationsResponse> {
        let input = ListDistributionConfigurationsRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.listDistributionConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listImageBuildVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listImageBuildVersionsPaginator(
        _ input: ListImageBuildVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListImageBuildVersionsRequest, ListImageBuildVersionsResponse> {
        return .init(
            input: input,
            command: self.listImageBuildVersions,
            inputKey: \ListImageBuildVersionsRequest.nextToken,
            outputKey: \ListImageBuildVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listImageBuildVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Use the following filters to streamline results:    name     osVersion     platform     type     version
    ///   - imageVersionArn: The Amazon Resource Name (ARN) of the image whose build versions you want to
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - logger: Logger used for logging
    @inlinable
    public func listImageBuildVersionsPaginator(
        filters: [Filter]? = nil,
        imageVersionArn: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListImageBuildVersionsRequest, ListImageBuildVersionsResponse> {
        let input = ListImageBuildVersionsRequest(
            filters: filters, 
            imageVersionArn: imageVersionArn, 
            maxResults: maxResults
        )
        return self.listImageBuildVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listImagePackages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listImagePackagesPaginator(
        _ input: ListImagePackagesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListImagePackagesRequest, ListImagePackagesResponse> {
        return .init(
            input: input,
            command: self.listImagePackages,
            inputKey: \ListImagePackagesRequest.nextToken,
            outputKey: \ListImagePackagesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listImagePackages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - imageBuildVersionArn: Filter results for the ListImagePackages request by the Image Build Version ARN
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - logger: Logger used for logging
    @inlinable
    public func listImagePackagesPaginator(
        imageBuildVersionArn: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListImagePackagesRequest, ListImagePackagesResponse> {
        let input = ListImagePackagesRequest(
            imageBuildVersionArn: imageBuildVersionArn, 
            maxResults: maxResults
        )
        return self.listImagePackagesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listImagePipelineImages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listImagePipelineImagesPaginator(
        _ input: ListImagePipelineImagesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListImagePipelineImagesRequest, ListImagePipelineImagesResponse> {
        return .init(
            input: input,
            command: self.listImagePipelineImages,
            inputKey: \ListImagePipelineImagesRequest.nextToken,
            outputKey: \ListImagePipelineImagesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listImagePipelineImages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Use the following filters to streamline results:    name     version
    ///   - imagePipelineArn: The Amazon Resource Name (ARN) of the image pipeline whose images you want to
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - logger: Logger used for logging
    @inlinable
    public func listImagePipelineImagesPaginator(
        filters: [Filter]? = nil,
        imagePipelineArn: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListImagePipelineImagesRequest, ListImagePipelineImagesResponse> {
        let input = ListImagePipelineImagesRequest(
            filters: filters, 
            imagePipelineArn: imagePipelineArn, 
            maxResults: maxResults
        )
        return self.listImagePipelineImagesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listImagePipelines(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listImagePipelinesPaginator(
        _ input: ListImagePipelinesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListImagePipelinesRequest, ListImagePipelinesResponse> {
        return .init(
            input: input,
            command: self.listImagePipelines,
            inputKey: \ListImagePipelinesRequest.nextToken,
            outputKey: \ListImagePipelinesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listImagePipelines(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Use the following filters to streamline results:    description     distributionConfigurationArn     imageRecipeArn     infrastructureConfigurationArn     name     status
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - logger: Logger used for logging
    @inlinable
    public func listImagePipelinesPaginator(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListImagePipelinesRequest, ListImagePipelinesResponse> {
        let input = ListImagePipelinesRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.listImagePipelinesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listImageRecipes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listImageRecipesPaginator(
        _ input: ListImageRecipesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListImageRecipesRequest, ListImageRecipesResponse> {
        return .init(
            input: input,
            command: self.listImageRecipes,
            inputKey: \ListImageRecipesRequest.nextToken,
            outputKey: \ListImageRecipesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listImageRecipes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Use the following filters to streamline results:    name     parentImage     platform
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - owner: You can specify the recipe owner to filter results by that owner. By default, this request will
    ///   - logger: Logger used for logging
    @inlinable
    public func listImageRecipesPaginator(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        owner: Ownership? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListImageRecipesRequest, ListImageRecipesResponse> {
        let input = ListImageRecipesRequest(
            filters: filters, 
            maxResults: maxResults, 
            owner: owner
        )
        return self.listImageRecipesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listImageScanFindingAggregations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listImageScanFindingAggregationsPaginator(
        _ input: ListImageScanFindingAggregationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListImageScanFindingAggregationsRequest, ListImageScanFindingAggregationsResponse> {
        return .init(
            input: input,
            command: self.listImageScanFindingAggregations,
            inputKey: \ListImageScanFindingAggregationsRequest.nextToken,
            outputKey: \ListImageScanFindingAggregationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listImageScanFindingAggregations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: 
    ///   - logger: Logger used for logging
    @inlinable
    public func listImageScanFindingAggregationsPaginator(
        filter: Filter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListImageScanFindingAggregationsRequest, ListImageScanFindingAggregationsResponse> {
        let input = ListImageScanFindingAggregationsRequest(
            filter: filter
        )
        return self.listImageScanFindingAggregationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listImageScanFindings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listImageScanFindingsPaginator(
        _ input: ListImageScanFindingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListImageScanFindingsRequest, ListImageScanFindingsResponse> {
        return .init(
            input: input,
            command: self.listImageScanFindings,
            inputKey: \ListImageScanFindingsRequest.nextToken,
            outputKey: \ListImageScanFindingsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listImageScanFindings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: An array of name value pairs that you can use to filter your results. You can use the
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - logger: Logger used for logging
    @inlinable
    public func listImageScanFindingsPaginator(
        filters: [ImageScanFindingsFilter]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListImageScanFindingsRequest, ListImageScanFindingsResponse> {
        let input = ListImageScanFindingsRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.listImageScanFindingsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listImages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listImagesPaginator(
        _ input: ListImagesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListImagesRequest, ListImagesResponse> {
        return .init(
            input: input,
            command: self.listImages,
            inputKey: \ListImagesRequest.nextToken,
            outputKey: \ListImagesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listImages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - byName: Requests a list of images with a specific recipe name.
    ///   - filters: Use the following filters to streamline results:    name     osVersion     platform     type     version
    ///   - includeDeprecated: Includes deprecated images in the response list.
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - owner: The owner defines which images you want to list. By default, this request will only
    ///   - logger: Logger used for logging
    @inlinable
    public func listImagesPaginator(
        byName: Bool? = nil,
        filters: [Filter]? = nil,
        includeDeprecated: Bool? = nil,
        maxResults: Int? = nil,
        owner: Ownership? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListImagesRequest, ListImagesResponse> {
        let input = ListImagesRequest(
            byName: byName, 
            filters: filters, 
            includeDeprecated: includeDeprecated, 
            maxResults: maxResults, 
            owner: owner
        )
        return self.listImagesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listInfrastructureConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listInfrastructureConfigurationsPaginator(
        _ input: ListInfrastructureConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListInfrastructureConfigurationsRequest, ListInfrastructureConfigurationsResponse> {
        return .init(
            input: input,
            command: self.listInfrastructureConfigurations,
            inputKey: \ListInfrastructureConfigurationsRequest.nextToken,
            outputKey: \ListInfrastructureConfigurationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listInfrastructureConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: You can filter on name to streamline results.
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - logger: Logger used for logging
    @inlinable
    public func listInfrastructureConfigurationsPaginator(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListInfrastructureConfigurationsRequest, ListInfrastructureConfigurationsResponse> {
        let input = ListInfrastructureConfigurationsRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.listInfrastructureConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listLifecycleExecutionResources(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listLifecycleExecutionResourcesPaginator(
        _ input: ListLifecycleExecutionResourcesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListLifecycleExecutionResourcesRequest, ListLifecycleExecutionResourcesResponse> {
        return .init(
            input: input,
            command: self.listLifecycleExecutionResources,
            inputKey: \ListLifecycleExecutionResourcesRequest.nextToken,
            outputKey: \ListLifecycleExecutionResourcesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listLifecycleExecutionResources(_:logger:)``.
    ///
    /// - Parameters:
    ///   - lifecycleExecutionId: Use the unique identifier for a runtime instance of the lifecycle policy to get runtime details.
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - parentResourceId: You can  leave this empty to get a list of Image Builder resources that were identified for lifecycle actions. To get a list of associated resources that are impacted for an individual resource (the parent), specify
    ///   - logger: Logger used for logging
    @inlinable
    public func listLifecycleExecutionResourcesPaginator(
        lifecycleExecutionId: String,
        maxResults: Int? = nil,
        parentResourceId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListLifecycleExecutionResourcesRequest, ListLifecycleExecutionResourcesResponse> {
        let input = ListLifecycleExecutionResourcesRequest(
            lifecycleExecutionId: lifecycleExecutionId, 
            maxResults: maxResults, 
            parentResourceId: parentResourceId
        )
        return self.listLifecycleExecutionResourcesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listLifecycleExecutions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listLifecycleExecutionsPaginator(
        _ input: ListLifecycleExecutionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListLifecycleExecutionsRequest, ListLifecycleExecutionsResponse> {
        return .init(
            input: input,
            command: self.listLifecycleExecutions,
            inputKey: \ListLifecycleExecutionsRequest.nextToken,
            outputKey: \ListLifecycleExecutionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listLifecycleExecutions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource for which to get a list of lifecycle runtime instances.
    ///   - logger: Logger used for logging
    @inlinable
    public func listLifecycleExecutionsPaginator(
        maxResults: Int? = nil,
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListLifecycleExecutionsRequest, ListLifecycleExecutionsResponse> {
        let input = ListLifecycleExecutionsRequest(
            maxResults: maxResults, 
            resourceArn: resourceArn
        )
        return self.listLifecycleExecutionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listLifecyclePolicies(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listLifecyclePoliciesPaginator(
        _ input: ListLifecyclePoliciesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListLifecyclePoliciesRequest, ListLifecyclePoliciesResponse> {
        return .init(
            input: input,
            command: self.listLifecyclePolicies,
            inputKey: \ListLifecyclePoliciesRequest.nextToken,
            outputKey: \ListLifecyclePoliciesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listLifecyclePolicies(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Streamline results based on one of the following values: Name,
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - logger: Logger used for logging
    @inlinable
    public func listLifecyclePoliciesPaginator(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListLifecyclePoliciesRequest, ListLifecyclePoliciesResponse> {
        let input = ListLifecyclePoliciesRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.listLifecyclePoliciesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listWaitingWorkflowSteps(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listWaitingWorkflowStepsPaginator(
        _ input: ListWaitingWorkflowStepsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListWaitingWorkflowStepsRequest, ListWaitingWorkflowStepsResponse> {
        return .init(
            input: input,
            command: self.listWaitingWorkflowSteps,
            inputKey: \ListWaitingWorkflowStepsRequest.nextToken,
            outputKey: \ListWaitingWorkflowStepsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listWaitingWorkflowSteps(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - logger: Logger used for logging
    @inlinable
    public func listWaitingWorkflowStepsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListWaitingWorkflowStepsRequest, ListWaitingWorkflowStepsResponse> {
        let input = ListWaitingWorkflowStepsRequest(
            maxResults: maxResults
        )
        return self.listWaitingWorkflowStepsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listWorkflowBuildVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkflowBuildVersionsPaginator(
        _ input: ListWorkflowBuildVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListWorkflowBuildVersionsRequest, ListWorkflowBuildVersionsResponse> {
        return .init(
            input: input,
            command: self.listWorkflowBuildVersions,
            inputKey: \ListWorkflowBuildVersionsRequest.nextToken,
            outputKey: \ListWorkflowBuildVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listWorkflowBuildVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - workflowVersionArn: The Amazon Resource Name (ARN) of the workflow resource for which to get a list of build versions.
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkflowBuildVersionsPaginator(
        maxResults: Int? = nil,
        workflowVersionArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListWorkflowBuildVersionsRequest, ListWorkflowBuildVersionsResponse> {
        let input = ListWorkflowBuildVersionsRequest(
            maxResults: maxResults, 
            workflowVersionArn: workflowVersionArn
        )
        return self.listWorkflowBuildVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listWorkflowExecutions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkflowExecutionsPaginator(
        _ input: ListWorkflowExecutionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListWorkflowExecutionsRequest, ListWorkflowExecutionsResponse> {
        return .init(
            input: input,
            command: self.listWorkflowExecutions,
            inputKey: \ListWorkflowExecutionsRequest.nextToken,
            outputKey: \ListWorkflowExecutionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listWorkflowExecutions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - imageBuildVersionArn: List all workflow runtime instances for the specified image build version
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkflowExecutionsPaginator(
        imageBuildVersionArn: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListWorkflowExecutionsRequest, ListWorkflowExecutionsResponse> {
        let input = ListWorkflowExecutionsRequest(
            imageBuildVersionArn: imageBuildVersionArn, 
            maxResults: maxResults
        )
        return self.listWorkflowExecutionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listWorkflowStepExecutions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkflowStepExecutionsPaginator(
        _ input: ListWorkflowStepExecutionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListWorkflowStepExecutionsRequest, ListWorkflowStepExecutionsResponse> {
        return .init(
            input: input,
            command: self.listWorkflowStepExecutions,
            inputKey: \ListWorkflowStepExecutionsRequest.nextToken,
            outputKey: \ListWorkflowStepExecutionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listWorkflowStepExecutions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - workflowExecutionId: The unique identifier that Image Builder assigned to keep track of runtime details
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkflowStepExecutionsPaginator(
        maxResults: Int? = nil,
        workflowExecutionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListWorkflowStepExecutionsRequest, ListWorkflowStepExecutionsResponse> {
        let input = ListWorkflowStepExecutionsRequest(
            maxResults: maxResults, 
            workflowExecutionId: workflowExecutionId
        )
        return self.listWorkflowStepExecutionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listWorkflows(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkflowsPaginator(
        _ input: ListWorkflowsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListWorkflowsRequest, ListWorkflowsResponse> {
        return .init(
            input: input,
            command: self.listWorkflows,
            inputKey: \ListWorkflowsRequest.nextToken,
            outputKey: \ListWorkflowsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listWorkflows(_:logger:)``.
    ///
    /// - Parameters:
    ///   - byName: Specify all or part of the workflow name to streamline results.
    ///   - filters: Used to streamline search results.
    ///   - maxResults: Specify the maximum number of items to return in a request.
    ///   - owner: Used to get a list of workflow build version filtered by the identity of the creator.
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkflowsPaginator(
        byName: Bool? = nil,
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        owner: Ownership? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListWorkflowsRequest, ListWorkflowsResponse> {
        let input = ListWorkflowsRequest(
            byName: byName, 
            filters: filters, 
            maxResults: maxResults, 
            owner: owner
        )
        return self.listWorkflowsPaginator(input, logger: logger)
    }
}

extension Imagebuilder.ListComponentBuildVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListComponentBuildVersionsRequest {
        return .init(
            componentVersionArn: self.componentVersionArn,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Imagebuilder.ListComponentsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListComponentsRequest {
        return .init(
            byName: self.byName,
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token,
            owner: self.owner
        )
    }
}

extension Imagebuilder.ListContainerRecipesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListContainerRecipesRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token,
            owner: self.owner
        )
    }
}

extension Imagebuilder.ListDistributionConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListDistributionConfigurationsRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Imagebuilder.ListImageBuildVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListImageBuildVersionsRequest {
        return .init(
            filters: self.filters,
            imageVersionArn: self.imageVersionArn,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Imagebuilder.ListImagePackagesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListImagePackagesRequest {
        return .init(
            imageBuildVersionArn: self.imageBuildVersionArn,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Imagebuilder.ListImagePipelineImagesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListImagePipelineImagesRequest {
        return .init(
            filters: self.filters,
            imagePipelineArn: self.imagePipelineArn,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Imagebuilder.ListImagePipelinesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListImagePipelinesRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Imagebuilder.ListImageRecipesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListImageRecipesRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token,
            owner: self.owner
        )
    }
}

extension Imagebuilder.ListImageScanFindingAggregationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListImageScanFindingAggregationsRequest {
        return .init(
            filter: self.filter,
            nextToken: token
        )
    }
}

extension Imagebuilder.ListImageScanFindingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListImageScanFindingsRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Imagebuilder.ListImagesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListImagesRequest {
        return .init(
            byName: self.byName,
            filters: self.filters,
            includeDeprecated: self.includeDeprecated,
            maxResults: self.maxResults,
            nextToken: token,
            owner: self.owner
        )
    }
}

extension Imagebuilder.ListInfrastructureConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListInfrastructureConfigurationsRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Imagebuilder.ListLifecycleExecutionResourcesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListLifecycleExecutionResourcesRequest {
        return .init(
            lifecycleExecutionId: self.lifecycleExecutionId,
            maxResults: self.maxResults,
            nextToken: token,
            parentResourceId: self.parentResourceId
        )
    }
}

extension Imagebuilder.ListLifecycleExecutionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListLifecycleExecutionsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            resourceArn: self.resourceArn
        )
    }
}

extension Imagebuilder.ListLifecyclePoliciesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListLifecyclePoliciesRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Imagebuilder.ListWaitingWorkflowStepsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListWaitingWorkflowStepsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Imagebuilder.ListWorkflowBuildVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListWorkflowBuildVersionsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            workflowVersionArn: self.workflowVersionArn
        )
    }
}

extension Imagebuilder.ListWorkflowExecutionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListWorkflowExecutionsRequest {
        return .init(
            imageBuildVersionArn: self.imageBuildVersionArn,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Imagebuilder.ListWorkflowStepExecutionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListWorkflowStepExecutionsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            workflowExecutionId: self.workflowExecutionId
        )
    }
}

extension Imagebuilder.ListWorkflowsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Imagebuilder.ListWorkflowsRequest {
        return .init(
            byName: self.byName,
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token,
            owner: self.owner
        )
    }
}
